libbgp  0.4.7
A C++ BGP Library.
libbgp_wrap.cc
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 3.0.10
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 
12 #ifndef SWIGPYTHON
13 #define SWIGPYTHON
14 #endif
15 
16 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
17 
18 
19 #ifdef __cplusplus
20 /* SwigValueWrapper is described in swig.swg */
21 template<typename T> class SwigValueWrapper {
22  struct SwigMovePointer {
23  T *ptr;
24  SwigMovePointer(T *p) : ptr(p) { }
25  ~SwigMovePointer() { delete ptr; }
26  SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
27  } pointer;
28  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
29  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
30 public:
31  SwigValueWrapper() : pointer(0) { }
32  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
33  operator T&() const { return *pointer.ptr; }
34  T *operator&() { return pointer.ptr; }
35 };
36 
37 template <typename T> T SwigValueInit() {
38  return T();
39 }
40 #endif
41 
42 /* -----------------------------------------------------------------------------
43  * This section contains generic SWIG labels for method/variable
44  * declarations/attributes, and other compiler dependent labels.
45  * ----------------------------------------------------------------------------- */
46 
47 /* template workaround for compilers that cannot correctly implement the C++ standard */
48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
50 # define SWIGTEMPLATEDISAMBIGUATOR template
51 # elif defined(__HP_aCC)
52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
54 # define SWIGTEMPLATEDISAMBIGUATOR template
55 # else
56 # define SWIGTEMPLATEDISAMBIGUATOR
57 # endif
58 #endif
59 
60 /* inline attribute */
61 #ifndef SWIGINLINE
62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
63 # define SWIGINLINE inline
64 # else
65 # define SWIGINLINE
66 # endif
67 #endif
68 
69 /* attribute recognised by some compilers to avoid 'unused' warnings */
70 #ifndef SWIGUNUSED
71 # if defined(__GNUC__)
72 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
73 # define SWIGUNUSED __attribute__ ((__unused__))
74 # else
75 # define SWIGUNUSED
76 # endif
77 # elif defined(__ICC)
78 # define SWIGUNUSED __attribute__ ((__unused__))
79 # else
80 # define SWIGUNUSED
81 # endif
82 #endif
83 
84 #ifndef SWIG_MSC_UNSUPPRESS_4505
85 # if defined(_MSC_VER)
86 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
87 # endif
88 #endif
89 
90 #ifndef SWIGUNUSEDPARM
91 # ifdef __cplusplus
92 # define SWIGUNUSEDPARM(p)
93 # else
94 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
95 # endif
96 #endif
97 
98 /* internal SWIG method */
99 #ifndef SWIGINTERN
100 # define SWIGINTERN static SWIGUNUSED
101 #endif
102 
103 /* internal inline SWIG method */
104 #ifndef SWIGINTERNINLINE
105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
106 #endif
107 
108 /* exporting methods */
109 #if defined(__GNUC__)
110 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
111 # ifndef GCC_HASCLASSVISIBILITY
112 # define GCC_HASCLASSVISIBILITY
113 # endif
114 # endif
115 #endif
116 
117 #ifndef SWIGEXPORT
118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
119 # if defined(STATIC_LINKED)
120 # define SWIGEXPORT
121 # else
122 # define SWIGEXPORT __declspec(dllexport)
123 # endif
124 # else
125 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
126 # define SWIGEXPORT __attribute__ ((visibility("default")))
127 # else
128 # define SWIGEXPORT
129 # endif
130 # endif
131 #endif
132 
133 /* calling conventions for Windows */
134 #ifndef SWIGSTDCALL
135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
136 # define SWIGSTDCALL __stdcall
137 # else
138 # define SWIGSTDCALL
139 # endif
140 #endif
141 
142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
144 # define _CRT_SECURE_NO_DEPRECATE
145 #endif
146 
147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
149 # define _SCL_SECURE_NO_DEPRECATE
150 #endif
151 
152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
155 #endif
156 
157 /* Intel's compiler complains if a variable which was never initialised is
158  * cast to void, which is a common idiom which we use to indicate that we
159  * are aware a variable isn't used. So we just silence that warning.
160  * See: https://github.com/swig/swig/issues/192 for more discussion.
161  */
162 #ifdef __INTEL_COMPILER
163 # pragma warning disable 592
164 #endif
165 
166 
167 #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
168 /* Use debug wrappers with the Python release dll */
169 # undef _DEBUG
170 # include <Python.h>
171 # define _DEBUG
172 #else
173 # include <Python.h>
174 #endif
175 
176 /* -----------------------------------------------------------------------------
177  * swigrun.swg
178  *
179  * This file contains generic C API SWIG runtime support for pointer
180  * type checking.
181  * ----------------------------------------------------------------------------- */
182 
183 /* This should only be incremented when either the layout of swig_type_info changes,
184  or for whatever reason, the runtime changes incompatibly */
185 #define SWIG_RUNTIME_VERSION "4"
186 
187 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
188 #ifdef SWIG_TYPE_TABLE
189 # define SWIG_QUOTE_STRING(x) #x
190 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
191 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
192 #else
193 # define SWIG_TYPE_TABLE_NAME
194 #endif
195 
196 /*
197  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
198  creating a static or dynamic library from the SWIG runtime code.
199  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
200 
201  But only do this if strictly necessary, ie, if you have problems
202  with your compiler or suchlike.
203 */
204 
205 #ifndef SWIGRUNTIME
206 # define SWIGRUNTIME SWIGINTERN
207 #endif
208 
209 #ifndef SWIGRUNTIMEINLINE
210 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
211 #endif
212 
213 /* Generic buffer size */
214 #ifndef SWIG_BUFFER_SIZE
215 # define SWIG_BUFFER_SIZE 1024
216 #endif
217 
218 /* Flags for pointer conversions */
219 #define SWIG_POINTER_DISOWN 0x1
220 #define SWIG_CAST_NEW_MEMORY 0x2
221 
222 /* Flags for new pointer objects */
223 #define SWIG_POINTER_OWN 0x1
224 
225 
226 /*
227  Flags/methods for returning states.
228 
229  The SWIG conversion methods, as ConvertPtr, return an integer
230  that tells if the conversion was successful or not. And if not,
231  an error code can be returned (see swigerrors.swg for the codes).
232 
233  Use the following macros/flags to set or process the returning
234  states.
235 
236  In old versions of SWIG, code such as the following was usually written:
237 
238  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
239  // success code
240  } else {
241  //fail code
242  }
243 
244  Now you can be more explicit:
245 
246  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
247  if (SWIG_IsOK(res)) {
248  // success code
249  } else {
250  // fail code
251  }
252 
253  which is the same really, but now you can also do
254 
255  Type *ptr;
256  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
257  if (SWIG_IsOK(res)) {
258  // success code
259  if (SWIG_IsNewObj(res) {
260  ...
261  delete *ptr;
262  } else {
263  ...
264  }
265  } else {
266  // fail code
267  }
268 
269  I.e., now SWIG_ConvertPtr can return new objects and you can
270  identify the case and take care of the deallocation. Of course that
271  also requires SWIG_ConvertPtr to return new result values, such as
272 
273  int SWIG_ConvertPtr(obj, ptr,...) {
274  if (<obj is ok>) {
275  if (<need new object>) {
276  *ptr = <ptr to new allocated object>;
277  return SWIG_NEWOBJ;
278  } else {
279  *ptr = <ptr to old object>;
280  return SWIG_OLDOBJ;
281  }
282  } else {
283  return SWIG_BADOBJ;
284  }
285  }
286 
287  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
288  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
289  SWIG errors code.
290 
291  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
292  allows to return the 'cast rank', for example, if you have this
293 
294  int food(double)
295  int fooi(int);
296 
297  and you call
298 
299  food(1) // cast rank '1' (1 -> 1.0)
300  fooi(1) // cast rank '0'
301 
302  just use the SWIG_AddCast()/SWIG_CheckState()
303 */
304 
305 #define SWIG_OK (0)
306 #define SWIG_ERROR (-1)
307 #define SWIG_IsOK(r) (r >= 0)
308 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
309 
310 /* The CastRankLimit says how many bits are used for the cast rank */
311 #define SWIG_CASTRANKLIMIT (1 << 8)
312 /* The NewMask denotes the object was created (using new/malloc) */
313 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
314 /* The TmpMask is for in/out typemaps that use temporal objects */
315 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
316 /* Simple returning values */
317 #define SWIG_BADOBJ (SWIG_ERROR)
318 #define SWIG_OLDOBJ (SWIG_OK)
319 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
320 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
321 /* Check, add and del mask methods */
322 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
323 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
324 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
325 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
326 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
327 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
328 
329 /* Cast-Rank Mode */
330 #if defined(SWIG_CASTRANK_MODE)
331 # ifndef SWIG_TypeRank
332 # define SWIG_TypeRank unsigned long
333 # endif
334 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
335 # define SWIG_MAXCASTRANK (2)
336 # endif
337 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
338 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
339 SWIGINTERNINLINE int SWIG_AddCast(int r) {
340  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
341 }
342 SWIGINTERNINLINE int SWIG_CheckState(int r) {
343  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
344 }
345 #else /* no cast-rank mode */
346 # define SWIG_AddCast(r) (r)
347 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
348 #endif
349 
350 
351 #include <string.h>
352 
353 #ifdef __cplusplus
354 extern "C" {
355 #endif
356 
357 typedef void *(*swig_converter_func)(void *, int *);
358 typedef struct swig_type_info *(*swig_dycast_func)(void **);
359 
360 /* Structure to store information on one type */
361 typedef struct swig_type_info {
362  const char *name; /* mangled name of this type */
363  const char *str; /* human readable name of this type */
364  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
365  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
366  void *clientdata; /* language specific type data */
367  int owndata; /* flag if the structure owns the clientdata */
369 
370 /* Structure to store a type and conversion function used for casting */
371 typedef struct swig_cast_info {
372  swig_type_info *type; /* pointer to type that is equivalent to this type */
373  swig_converter_func converter; /* function to cast the void pointers */
374  struct swig_cast_info *next; /* pointer to next cast in linked list */
375  struct swig_cast_info *prev; /* pointer to the previous cast */
377 
378 /* Structure used to store module information
379  * Each module generates one structure like this, and the runtime collects
380  * all of these structures and stores them in a circularly linked list.*/
381 typedef struct swig_module_info {
382  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
383  size_t size; /* Number of types in this module */
384  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
385  swig_type_info **type_initial; /* Array of initially generated type structures */
386  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
387  void *clientdata; /* Language specific module data */
389 
390 /*
391  Compare two type names skipping the space characters, therefore
392  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
393 
394  Return 0 when the two name types are equivalent, as in
395  strncmp, but skipping ' '.
396 */
397 SWIGRUNTIME int
398 SWIG_TypeNameComp(const char *f1, const char *l1,
399  const char *f2, const char *l2) {
400  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
401  while ((*f1 == ' ') && (f1 != l1)) ++f1;
402  while ((*f2 == ' ') && (f2 != l2)) ++f2;
403  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
404  }
405  return (int)((l1 - f1) - (l2 - f2));
406 }
407 
408 /*
409  Check type equivalence in a name list like <name1>|<name2>|...
410  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
411 */
412 SWIGRUNTIME int
413 SWIG_TypeCmp(const char *nb, const char *tb) {
414  int equiv = 1;
415  const char* te = tb + strlen(tb);
416  const char* ne = nb;
417  while (equiv != 0 && *ne) {
418  for (nb = ne; *ne; ++ne) {
419  if (*ne == '|') break;
420  }
421  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
422  if (*ne) ++ne;
423  }
424  return equiv;
425 }
426 
427 /*
428  Check type equivalence in a name list like <name1>|<name2>|...
429  Return 0 if not equal, 1 if equal
430 */
431 SWIGRUNTIME int
432 SWIG_TypeEquiv(const char *nb, const char *tb) {
433  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
434 }
435 
436 /*
437  Check the typename
438 */
439 SWIGRUNTIME swig_cast_info *
440 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
441  if (ty) {
442  swig_cast_info *iter = ty->cast;
443  while (iter) {
444  if (strcmp(iter->type->name, c) == 0) {
445  if (iter == ty->cast)
446  return iter;
447  /* Move iter to the top of the linked list */
448  iter->prev->next = iter->next;
449  if (iter->next)
450  iter->next->prev = iter->prev;
451  iter->next = ty->cast;
452  iter->prev = 0;
453  if (ty->cast) ty->cast->prev = iter;
454  ty->cast = iter;
455  return iter;
456  }
457  iter = iter->next;
458  }
459  }
460  return 0;
461 }
462 
463 /*
464  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
465 */
466 SWIGRUNTIME swig_cast_info *
467 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
468  if (ty) {
469  swig_cast_info *iter = ty->cast;
470  while (iter) {
471  if (iter->type == from) {
472  if (iter == ty->cast)
473  return iter;
474  /* Move iter to the top of the linked list */
475  iter->prev->next = iter->next;
476  if (iter->next)
477  iter->next->prev = iter->prev;
478  iter->next = ty->cast;
479  iter->prev = 0;
480  if (ty->cast) ty->cast->prev = iter;
481  ty->cast = iter;
482  return iter;
483  }
484  iter = iter->next;
485  }
486  }
487  return 0;
488 }
489 
490 /*
491  Cast a pointer up an inheritance hierarchy
492 */
493 SWIGRUNTIMEINLINE void *
494 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
495  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
496 }
497 
498 /*
499  Dynamic pointer casting. Down an inheritance hierarchy
500 */
501 SWIGRUNTIME swig_type_info *
502 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
503  swig_type_info *lastty = ty;
504  if (!ty || !ty->dcast) return ty;
505  while (ty && (ty->dcast)) {
506  ty = (*ty->dcast)(ptr);
507  if (ty) lastty = ty;
508  }
509  return lastty;
510 }
511 
512 /*
513  Return the name associated with this type
514 */
515 SWIGRUNTIMEINLINE const char *
516 SWIG_TypeName(const swig_type_info *ty) {
517  return ty->name;
518 }
519 
520 /*
521  Return the pretty name associated with this type,
522  that is an unmangled type name in a form presentable to the user.
523 */
524 SWIGRUNTIME const char *
525 SWIG_TypePrettyName(const swig_type_info *type) {
526  /* The "str" field contains the equivalent pretty names of the
527  type, separated by vertical-bar characters. We choose
528  to print the last name, as it is often (?) the most
529  specific. */
530  if (!type) return NULL;
531  if (type->str != NULL) {
532  const char *last_name = type->str;
533  const char *s;
534  for (s = type->str; *s; s++)
535  if (*s == '|') last_name = s+1;
536  return last_name;
537  }
538  else
539  return type->name;
540 }
541 
542 /*
543  Set the clientdata field for a type
544 */
545 SWIGRUNTIME void
546 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
547  swig_cast_info *cast = ti->cast;
548  /* if (ti->clientdata == clientdata) return; */
549  ti->clientdata = clientdata;
550 
551  while (cast) {
552  if (!cast->converter) {
553  swig_type_info *tc = cast->type;
554  if (!tc->clientdata) {
555  SWIG_TypeClientData(tc, clientdata);
556  }
557  }
558  cast = cast->next;
559  }
560 }
561 SWIGRUNTIME void
562 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
563  SWIG_TypeClientData(ti, clientdata);
564  ti->owndata = 1;
565 }
566 
567 /*
568  Search for a swig_type_info structure only by mangled name
569  Search is a O(log #types)
570 
571  We start searching at module start, and finish searching when start == end.
572  Note: if start == end at the beginning of the function, we go all the way around
573  the circular list.
574 */
575 SWIGRUNTIME swig_type_info *
576 SWIG_MangledTypeQueryModule(swig_module_info *start,
577  swig_module_info *end,
578  const char *name) {
579  swig_module_info *iter = start;
580  do {
581  if (iter->size) {
582  size_t l = 0;
583  size_t r = iter->size - 1;
584  do {
585  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
586  size_t i = (l + r) >> 1;
587  const char *iname = iter->types[i]->name;
588  if (iname) {
589  int compare = strcmp(name, iname);
590  if (compare == 0) {
591  return iter->types[i];
592  } else if (compare < 0) {
593  if (i) {
594  r = i - 1;
595  } else {
596  break;
597  }
598  } else if (compare > 0) {
599  l = i + 1;
600  }
601  } else {
602  break; /* should never happen */
603  }
604  } while (l <= r);
605  }
606  iter = iter->next;
607  } while (iter != end);
608  return 0;
609 }
610 
611 /*
612  Search for a swig_type_info structure for either a mangled name or a human readable name.
613  It first searches the mangled names of the types, which is a O(log #types)
614  If a type is not found it then searches the human readable names, which is O(#types).
615 
616  We start searching at module start, and finish searching when start == end.
617  Note: if start == end at the beginning of the function, we go all the way around
618  the circular list.
619 */
620 SWIGRUNTIME swig_type_info *
621 SWIG_TypeQueryModule(swig_module_info *start,
622  swig_module_info *end,
623  const char *name) {
624  /* STEP 1: Search the name field using binary search */
625  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
626  if (ret) {
627  return ret;
628  } else {
629  /* STEP 2: If the type hasn't been found, do a complete search
630  of the str field (the human readable name) */
631  swig_module_info *iter = start;
632  do {
633  size_t i = 0;
634  for (; i < iter->size; ++i) {
635  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
636  return iter->types[i];
637  }
638  iter = iter->next;
639  } while (iter != end);
640  }
641 
642  /* neither found a match */
643  return 0;
644 }
645 
646 /*
647  Pack binary data into a string
648 */
649 SWIGRUNTIME char *
650 SWIG_PackData(char *c, void *ptr, size_t sz) {
651  static const char hex[17] = "0123456789abcdef";
652  const unsigned char *u = (unsigned char *) ptr;
653  const unsigned char *eu = u + sz;
654  for (; u != eu; ++u) {
655  unsigned char uu = *u;
656  *(c++) = hex[(uu & 0xf0) >> 4];
657  *(c++) = hex[uu & 0xf];
658  }
659  return c;
660 }
661 
662 /*
663  Unpack binary data from a string
664 */
665 SWIGRUNTIME const char *
666 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
667  unsigned char *u = (unsigned char *) ptr;
668  const unsigned char *eu = u + sz;
669  for (; u != eu; ++u) {
670  char d = *(c++);
671  unsigned char uu;
672  if ((d >= '0') && (d <= '9'))
673  uu = (unsigned char)((d - '0') << 4);
674  else if ((d >= 'a') && (d <= 'f'))
675  uu = (unsigned char)((d - ('a'-10)) << 4);
676  else
677  return (char *) 0;
678  d = *(c++);
679  if ((d >= '0') && (d <= '9'))
680  uu |= (unsigned char)(d - '0');
681  else if ((d >= 'a') && (d <= 'f'))
682  uu |= (unsigned char)(d - ('a'-10));
683  else
684  return (char *) 0;
685  *u = uu;
686  }
687  return c;
688 }
689 
690 /*
691  Pack 'void *' into a string buffer.
692 */
693 SWIGRUNTIME char *
694 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
695  char *r = buff;
696  if ((2*sizeof(void *) + 2) > bsz) return 0;
697  *(r++) = '_';
698  r = SWIG_PackData(r,&ptr,sizeof(void *));
699  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
700  strcpy(r,name);
701  return buff;
702 }
703 
704 SWIGRUNTIME const char *
705 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
706  if (*c != '_') {
707  if (strcmp(c,"NULL") == 0) {
708  *ptr = (void *) 0;
709  return name;
710  } else {
711  return 0;
712  }
713  }
714  return SWIG_UnpackData(++c,ptr,sizeof(void *));
715 }
716 
717 SWIGRUNTIME char *
718 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
719  char *r = buff;
720  size_t lname = (name ? strlen(name) : 0);
721  if ((2*sz + 2 + lname) > bsz) return 0;
722  *(r++) = '_';
723  r = SWIG_PackData(r,ptr,sz);
724  if (lname) {
725  strncpy(r,name,lname+1);
726  } else {
727  *r = 0;
728  }
729  return buff;
730 }
731 
732 SWIGRUNTIME const char *
733 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
734  if (*c != '_') {
735  if (strcmp(c,"NULL") == 0) {
736  memset(ptr,0,sz);
737  return name;
738  } else {
739  return 0;
740  }
741  }
742  return SWIG_UnpackData(++c,ptr,sz);
743 }
744 
745 #ifdef __cplusplus
746 }
747 #endif
748 
749 /* Errors in SWIG */
750 #define SWIG_UnknownError -1
751 #define SWIG_IOError -2
752 #define SWIG_RuntimeError -3
753 #define SWIG_IndexError -4
754 #define SWIG_TypeError -5
755 #define SWIG_DivisionByZero -6
756 #define SWIG_OverflowError -7
757 #define SWIG_SyntaxError -8
758 #define SWIG_ValueError -9
759 #define SWIG_SystemError -10
760 #define SWIG_AttributeError -11
761 #define SWIG_MemoryError -12
762 #define SWIG_NullReferenceError -13
763 
764 
765 
766 /* Compatibility macros for Python 3 */
767 #if PY_VERSION_HEX >= 0x03000000
768 
769 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
770 #define PyInt_Check(x) PyLong_Check(x)
771 #define PyInt_AsLong(x) PyLong_AsLong(x)
772 #define PyInt_FromLong(x) PyLong_FromLong(x)
773 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
774 #define PyString_Check(name) PyBytes_Check(name)
775 #define PyString_FromString(x) PyUnicode_FromString(x)
776 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
777 #define PyString_AsString(str) PyBytes_AsString(str)
778 #define PyString_Size(str) PyBytes_Size(str)
779 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
780 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
781 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
782 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
783 
784 #endif
785 
786 #ifndef Py_TYPE
787 # define Py_TYPE(op) ((op)->ob_type)
788 #endif
789 
790 /* SWIG APIs for compatibility of both Python 2 & 3 */
791 
792 #if PY_VERSION_HEX >= 0x03000000
793 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
794 #else
795 # define SWIG_Python_str_FromFormat PyString_FromFormat
796 #endif
797 
798 
799 /* Warning: This function will allocate a new string in Python 3,
800  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
801  */
802 SWIGINTERN char*
803 SWIG_Python_str_AsChar(PyObject *str)
804 {
805 #if PY_VERSION_HEX >= 0x03000000
806  char *cstr;
807  char *newstr;
808  Py_ssize_t len;
809  str = PyUnicode_AsUTF8String(str);
810  PyBytes_AsStringAndSize(str, &cstr, &len);
811  newstr = (char *) malloc(len+1);
812  memcpy(newstr, cstr, len+1);
813  Py_XDECREF(str);
814  return newstr;
815 #else
816  return PyString_AsString(str);
817 #endif
818 }
819 
820 #if PY_VERSION_HEX >= 0x03000000
821 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
822 #else
823 # define SWIG_Python_str_DelForPy3(x)
824 #endif
825 
826 
827 SWIGINTERN PyObject*
828 SWIG_Python_str_FromChar(const char *c)
829 {
830 #if PY_VERSION_HEX >= 0x03000000
831  return PyUnicode_FromString(c);
832 #else
833  return PyString_FromString(c);
834 #endif
835 }
836 
837 /* Add PyOS_snprintf for old Pythons */
838 #if PY_VERSION_HEX < 0x02020000
839 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
840 # define PyOS_snprintf _snprintf
841 # else
842 # define PyOS_snprintf snprintf
843 # endif
844 #endif
845 
846 /* A crude PyString_FromFormat implementation for old Pythons */
847 #if PY_VERSION_HEX < 0x02020000
848 
849 #ifndef SWIG_PYBUFFER_SIZE
850 # define SWIG_PYBUFFER_SIZE 1024
851 #endif
852 
853 static PyObject *
854 PyString_FromFormat(const char *fmt, ...) {
855  va_list ap;
856  char buf[SWIG_PYBUFFER_SIZE * 2];
857  int res;
858  va_start(ap, fmt);
859  res = vsnprintf(buf, sizeof(buf), fmt, ap);
860  va_end(ap);
861  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
862 }
863 #endif
864 
865 #ifndef PyObject_DEL
866 # define PyObject_DEL PyObject_Del
867 #endif
868 
869 /* A crude PyExc_StopIteration exception for old Pythons */
870 #if PY_VERSION_HEX < 0x02020000
871 # ifndef PyExc_StopIteration
872 # define PyExc_StopIteration PyExc_RuntimeError
873 # endif
874 # ifndef PyObject_GenericGetAttr
875 # define PyObject_GenericGetAttr 0
876 # endif
877 #endif
878 
879 /* Py_NotImplemented is defined in 2.1 and up. */
880 #if PY_VERSION_HEX < 0x02010000
881 # ifndef Py_NotImplemented
882 # define Py_NotImplemented PyExc_RuntimeError
883 # endif
884 #endif
885 
886 /* A crude PyString_AsStringAndSize implementation for old Pythons */
887 #if PY_VERSION_HEX < 0x02010000
888 # ifndef PyString_AsStringAndSize
889 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
890 # endif
891 #endif
892 
893 /* PySequence_Size for old Pythons */
894 #if PY_VERSION_HEX < 0x02000000
895 # ifndef PySequence_Size
896 # define PySequence_Size PySequence_Length
897 # endif
898 #endif
899 
900 /* PyBool_FromLong for old Pythons */
901 #if PY_VERSION_HEX < 0x02030000
902 static
903 PyObject *PyBool_FromLong(long ok)
904 {
905  PyObject *result = ok ? Py_True : Py_False;
906  Py_INCREF(result);
907  return result;
908 }
909 #endif
910 
911 /* Py_ssize_t for old Pythons */
912 /* This code is as recommended by: */
913 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
914 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
915 typedef int Py_ssize_t;
916 # define PY_SSIZE_T_MAX INT_MAX
917 # define PY_SSIZE_T_MIN INT_MIN
918 typedef inquiry lenfunc;
919 typedef intargfunc ssizeargfunc;
920 typedef intintargfunc ssizessizeargfunc;
921 typedef intobjargproc ssizeobjargproc;
922 typedef intintobjargproc ssizessizeobjargproc;
923 typedef getreadbufferproc readbufferproc;
924 typedef getwritebufferproc writebufferproc;
925 typedef getsegcountproc segcountproc;
926 typedef getcharbufferproc charbufferproc;
927 static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
928 {
929  long result = 0;
930  PyObject *i = PyNumber_Int(x);
931  if (i) {
932  result = PyInt_AsLong(i);
933  Py_DECREF(i);
934  }
935  return result;
936 }
937 #endif
938 
939 #if PY_VERSION_HEX < 0x02050000
940 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
941 #endif
942 
943 #if PY_VERSION_HEX < 0x02040000
944 #define Py_VISIT(op) \
945  do { \
946  if (op) { \
947  int vret = visit((op), arg); \
948  if (vret) \
949  return vret; \
950  } \
951  } while (0)
952 #endif
953 
954 #if PY_VERSION_HEX < 0x02030000
955 typedef struct {
956  PyTypeObject type;
957  PyNumberMethods as_number;
958  PyMappingMethods as_mapping;
959  PySequenceMethods as_sequence;
960  PyBufferProcs as_buffer;
961  PyObject *name, *slots;
963 #endif
964 
965 #if PY_VERSION_HEX < 0x02030000
966 typedef destructor freefunc;
967 #endif
968 
969 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
970  (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
971  (PY_MAJOR_VERSION > 3))
972 # define SWIGPY_USE_CAPSULE
973 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
974 #endif
975 
976 #if PY_VERSION_HEX < 0x03020000
977 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
978 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
979 #endif
980 
981 /* -----------------------------------------------------------------------------
982  * error manipulation
983  * ----------------------------------------------------------------------------- */
984 
985 SWIGRUNTIME PyObject*
986 SWIG_Python_ErrorType(int code) {
987  PyObject* type = 0;
988  switch(code) {
989  case SWIG_MemoryError:
990  type = PyExc_MemoryError;
991  break;
992  case SWIG_IOError:
993  type = PyExc_IOError;
994  break;
995  case SWIG_RuntimeError:
996  type = PyExc_RuntimeError;
997  break;
998  case SWIG_IndexError:
999  type = PyExc_IndexError;
1000  break;
1001  case SWIG_TypeError:
1002  type = PyExc_TypeError;
1003  break;
1004  case SWIG_DivisionByZero:
1005  type = PyExc_ZeroDivisionError;
1006  break;
1007  case SWIG_OverflowError:
1008  type = PyExc_OverflowError;
1009  break;
1010  case SWIG_SyntaxError:
1011  type = PyExc_SyntaxError;
1012  break;
1013  case SWIG_ValueError:
1014  type = PyExc_ValueError;
1015  break;
1016  case SWIG_SystemError:
1017  type = PyExc_SystemError;
1018  break;
1019  case SWIG_AttributeError:
1020  type = PyExc_AttributeError;
1021  break;
1022  default:
1023  type = PyExc_RuntimeError;
1024  }
1025  return type;
1026 }
1027 
1028 
1029 SWIGRUNTIME void
1030 SWIG_Python_AddErrorMsg(const char* mesg)
1031 {
1032  PyObject *type = 0;
1033  PyObject *value = 0;
1034  PyObject *traceback = 0;
1035 
1036  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1037  if (value) {
1038  char *tmp;
1039  PyObject *old_str = PyObject_Str(value);
1040  PyErr_Clear();
1041  Py_XINCREF(type);
1042 
1043  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1044  SWIG_Python_str_DelForPy3(tmp);
1045  Py_DECREF(old_str);
1046  Py_DECREF(value);
1047  } else {
1048  PyErr_SetString(PyExc_RuntimeError, mesg);
1049  }
1050 }
1051 
1052 #if defined(SWIG_PYTHON_NO_THREADS)
1053 # if defined(SWIG_PYTHON_THREADS)
1054 # undef SWIG_PYTHON_THREADS
1055 # endif
1056 #endif
1057 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1058 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1059 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1060 # define SWIG_PYTHON_USE_GIL
1061 # endif
1062 # endif
1063 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1064 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1065 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1066 # endif
1067 # ifdef __cplusplus /* C++ code */
1068  class SWIG_Python_Thread_Block {
1069  bool status;
1070  PyGILState_STATE state;
1071  public:
1072  void end() { if (status) { PyGILState_Release(state); status = false;} }
1073  SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1074  ~SWIG_Python_Thread_Block() { end(); }
1075  };
1076  class SWIG_Python_Thread_Allow {
1077  bool status;
1078  PyThreadState *save;
1079  public:
1080  void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1081  SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1082  ~SWIG_Python_Thread_Allow() { end(); }
1083  };
1084 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1085 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1086 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1087 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1088 # else /* C code */
1089 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1090 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1091 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1092 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1093 # endif
1094 # else /* Old thread way, not implemented, user must provide it */
1095 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1096 # define SWIG_PYTHON_INITIALIZE_THREADS
1097 # endif
1098 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1099 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1100 # endif
1101 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1102 # define SWIG_PYTHON_THREAD_END_BLOCK
1103 # endif
1104 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1105 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1106 # endif
1107 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1108 # define SWIG_PYTHON_THREAD_END_ALLOW
1109 # endif
1110 # endif
1111 #else /* No thread support */
1112 # define SWIG_PYTHON_INITIALIZE_THREADS
1113 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1114 # define SWIG_PYTHON_THREAD_END_BLOCK
1115 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1116 # define SWIG_PYTHON_THREAD_END_ALLOW
1117 #endif
1118 
1119 /* -----------------------------------------------------------------------------
1120  * Python API portion that goes into the runtime
1121  * ----------------------------------------------------------------------------- */
1122 
1123 #ifdef __cplusplus
1124 extern "C" {
1125 #endif
1126 
1127 /* -----------------------------------------------------------------------------
1128  * Constant declarations
1129  * ----------------------------------------------------------------------------- */
1130 
1131 /* Constant Types */
1132 #define SWIG_PY_POINTER 4
1133 #define SWIG_PY_BINARY 5
1134 
1135 /* Constant information structure */
1136 typedef struct swig_const_info {
1137  int type;
1138  char *name;
1139  long lvalue;
1140  double dvalue;
1141  void *pvalue;
1142  swig_type_info **ptype;
1143 } swig_const_info;
1144 
1145 
1146 /* -----------------------------------------------------------------------------
1147  * Wrapper of PyInstanceMethod_New() used in Python 3
1148  * It is exported to the generated module, used for -fastproxy
1149  * ----------------------------------------------------------------------------- */
1150 #if PY_VERSION_HEX >= 0x03000000
1151 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1152 {
1153  return PyInstanceMethod_New(func);
1154 }
1155 #else
1156 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1157 {
1158  return NULL;
1159 }
1160 #endif
1161 
1162 #ifdef __cplusplus
1163 }
1164 #endif
1165 
1166 
1167 /* -----------------------------------------------------------------------------
1168  * pyrun.swg
1169  *
1170  * This file contains the runtime support for Python modules
1171  * and includes code for managing global variables and pointer
1172  * type checking.
1173  *
1174  * ----------------------------------------------------------------------------- */
1175 
1176 /* Common SWIG API */
1177 
1178 /* for raw pointers */
1179 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1180 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1181 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1182 
1183 #ifdef SWIGPYTHON_BUILTIN
1184 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1185 #else
1186 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1187 #endif
1188 
1189 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1190 
1191 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1192 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1193 #define swig_owntype int
1194 
1195 /* for raw packed data */
1196 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1197 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1198 
1199 /* for class or struct pointers */
1200 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1201 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1202 
1203 /* for C or C++ function pointers */
1204 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1205 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1206 
1207 /* for C++ member pointers, ie, member methods */
1208 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1209 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1210 
1211 
1212 /* Runtime API */
1213 
1214 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1215 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1216 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1217 
1218 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1219 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1220 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1221 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1222 #define SWIG_fail goto fail
1223 
1224 
1225 /* Runtime API implementation */
1226 
1227 /* Error manipulation */
1228 
1229 SWIGINTERN void
1230 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1231  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1232  PyErr_SetObject(errtype, obj);
1233  Py_DECREF(obj);
1234  SWIG_PYTHON_THREAD_END_BLOCK;
1235 }
1236 
1237 SWIGINTERN void
1238 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1239  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1240  PyErr_SetString(errtype, msg);
1241  SWIG_PYTHON_THREAD_END_BLOCK;
1242 }
1243 
1244 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1245 
1246 /* Set a constant value */
1247 
1248 #if defined(SWIGPYTHON_BUILTIN)
1249 
1250 SWIGINTERN void
1251 SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1252  PyObject *s = PyString_InternFromString(key);
1253  PyList_Append(seq, s);
1254  Py_DECREF(s);
1255 }
1256 
1257 SWIGINTERN void
1258 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1259 #if PY_VERSION_HEX < 0x02030000
1260  PyDict_SetItemString(d, (char *)name, obj);
1261 #else
1262  PyDict_SetItemString(d, name, obj);
1263 #endif
1264  Py_DECREF(obj);
1265  if (public_interface)
1266  SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1267 }
1268 
1269 #else
1270 
1271 SWIGINTERN void
1272 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1273 #if PY_VERSION_HEX < 0x02030000
1274  PyDict_SetItemString(d, (char *)name, obj);
1275 #else
1276  PyDict_SetItemString(d, name, obj);
1277 #endif
1278  Py_DECREF(obj);
1279 }
1280 
1281 #endif
1282 
1283 /* Append a value to the result obj */
1284 
1285 SWIGINTERN PyObject*
1286 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1287 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1288  if (!result) {
1289  result = obj;
1290  } else if (result == Py_None) {
1291  Py_DECREF(result);
1292  result = obj;
1293  } else {
1294  if (!PyList_Check(result)) {
1295  PyObject *o2 = result;
1296  result = PyList_New(1);
1297  PyList_SetItem(result, 0, o2);
1298  }
1299  PyList_Append(result,obj);
1300  Py_DECREF(obj);
1301  }
1302  return result;
1303 #else
1304  PyObject* o2;
1305  PyObject* o3;
1306  if (!result) {
1307  result = obj;
1308  } else if (result == Py_None) {
1309  Py_DECREF(result);
1310  result = obj;
1311  } else {
1312  if (!PyTuple_Check(result)) {
1313  o2 = result;
1314  result = PyTuple_New(1);
1315  PyTuple_SET_ITEM(result, 0, o2);
1316  }
1317  o3 = PyTuple_New(1);
1318  PyTuple_SET_ITEM(o3, 0, obj);
1319  o2 = result;
1320  result = PySequence_Concat(o2, o3);
1321  Py_DECREF(o2);
1322  Py_DECREF(o3);
1323  }
1324  return result;
1325 #endif
1326 }
1327 
1328 /* Unpack the argument tuple */
1329 
1330 SWIGINTERN Py_ssize_t
1331 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1332 {
1333  if (!args) {
1334  if (!min && !max) {
1335  return 1;
1336  } else {
1337  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1338  name, (min == max ? "" : "at least "), (int)min);
1339  return 0;
1340  }
1341  }
1342  if (!PyTuple_Check(args)) {
1343  if (min <= 1 && max >= 1) {
1344  Py_ssize_t i;
1345  objs[0] = args;
1346  for (i = 1; i < max; ++i) {
1347  objs[i] = 0;
1348  }
1349  return 2;
1350  }
1351  PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1352  return 0;
1353  } else {
1354  Py_ssize_t l = PyTuple_GET_SIZE(args);
1355  if (l < min) {
1356  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1357  name, (min == max ? "" : "at least "), (int)min, (int)l);
1358  return 0;
1359  } else if (l > max) {
1360  PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1361  name, (min == max ? "" : "at most "), (int)max, (int)l);
1362  return 0;
1363  } else {
1364  Py_ssize_t i;
1365  for (i = 0; i < l; ++i) {
1366  objs[i] = PyTuple_GET_ITEM(args, i);
1367  }
1368  for (; l < max; ++l) {
1369  objs[l] = 0;
1370  }
1371  return i + 1;
1372  }
1373  }
1374 }
1375 
1376 /* A functor is a function object with one single object argument */
1377 #if PY_VERSION_HEX >= 0x02020000
1378 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1379 #else
1380 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1381 #endif
1382 
1383 /*
1384  Helper for static pointer initialization for both C and C++ code, for example
1385  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1386 */
1387 #ifdef __cplusplus
1388 #define SWIG_STATIC_POINTER(var) var
1389 #else
1390 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1391 #endif
1392 
1393 /* -----------------------------------------------------------------------------
1394  * Pointer declarations
1395  * ----------------------------------------------------------------------------- */
1396 
1397 /* Flags for new pointer objects */
1398 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1399 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1400 
1401 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1402 
1403 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1404 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1405 
1406 #ifdef __cplusplus
1407 extern "C" {
1408 #endif
1409 
1410 /* How to access Py_None */
1411 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1412 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1413 # ifndef SWIG_PYTHON_BUILD_NONE
1414 # define SWIG_PYTHON_BUILD_NONE
1415 # endif
1416 # endif
1417 #endif
1418 
1419 #ifdef SWIG_PYTHON_BUILD_NONE
1420 # ifdef Py_None
1421 # undef Py_None
1422 # define Py_None SWIG_Py_None()
1423 # endif
1424 SWIGRUNTIMEINLINE PyObject *
1425 _SWIG_Py_None(void)
1426 {
1427  PyObject *none = Py_BuildValue((char*)"");
1428  Py_DECREF(none);
1429  return none;
1430 }
1431 SWIGRUNTIME PyObject *
1432 SWIG_Py_None(void)
1433 {
1434  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1435  return none;
1436 }
1437 #endif
1438 
1439 /* The python void return value */
1440 
1441 SWIGRUNTIMEINLINE PyObject *
1442 SWIG_Py_Void(void)
1443 {
1444  PyObject *none = Py_None;
1445  Py_INCREF(none);
1446  return none;
1447 }
1448 
1449 /* SwigPyClientData */
1450 
1451 typedef struct {
1452  PyObject *klass;
1453  PyObject *newraw;
1454  PyObject *newargs;
1455  PyObject *destroy;
1456  int delargs;
1457  int implicitconv;
1458  PyTypeObject *pytype;
1460 
1461 SWIGRUNTIMEINLINE int
1462 SWIG_Python_CheckImplicit(swig_type_info *ty)
1463 {
1464  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1465  return data ? data->implicitconv : 0;
1466 }
1467 
1468 SWIGRUNTIMEINLINE PyObject *
1469 SWIG_Python_ExceptionType(swig_type_info *desc) {
1470  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1471  PyObject *klass = data ? data->klass : 0;
1472  return (klass ? klass : PyExc_RuntimeError);
1473 }
1474 
1475 
1476 SWIGRUNTIME SwigPyClientData *
1477 SwigPyClientData_New(PyObject* obj)
1478 {
1479  if (!obj) {
1480  return 0;
1481  } else {
1482  SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1483  /* the klass element */
1484  data->klass = obj;
1485  Py_INCREF(data->klass);
1486  /* the newraw method and newargs arguments used to create a new raw instance */
1487  if (PyClass_Check(obj)) {
1488  data->newraw = 0;
1489  data->newargs = obj;
1490  Py_INCREF(obj);
1491  } else {
1492 #if (PY_VERSION_HEX < 0x02020000)
1493  data->newraw = 0;
1494 #else
1495  data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1496 #endif
1497  if (data->newraw) {
1498  Py_INCREF(data->newraw);
1499  data->newargs = PyTuple_New(1);
1500  PyTuple_SetItem(data->newargs, 0, obj);
1501  } else {
1502  data->newargs = obj;
1503  }
1504  Py_INCREF(data->newargs);
1505  }
1506  /* the destroy method, aka as the C++ delete method */
1507  data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1508  if (PyErr_Occurred()) {
1509  PyErr_Clear();
1510  data->destroy = 0;
1511  }
1512  if (data->destroy) {
1513  int flags;
1514  Py_INCREF(data->destroy);
1515  flags = PyCFunction_GET_FLAGS(data->destroy);
1516 #ifdef METH_O
1517  data->delargs = !(flags & (METH_O));
1518 #else
1519  data->delargs = 0;
1520 #endif
1521  } else {
1522  data->delargs = 0;
1523  }
1524  data->implicitconv = 0;
1525  data->pytype = 0;
1526  return data;
1527  }
1528 }
1529 
1530 SWIGRUNTIME void
1531 SwigPyClientData_Del(SwigPyClientData *data) {
1532  Py_XDECREF(data->newraw);
1533  Py_XDECREF(data->newargs);
1534  Py_XDECREF(data->destroy);
1535 }
1536 
1537 /* =============== SwigPyObject =====================*/
1538 
1539 typedef struct {
1540  PyObject_HEAD
1541  void *ptr;
1542  swig_type_info *ty;
1543  int own;
1544  PyObject *next;
1545 #ifdef SWIGPYTHON_BUILTIN
1546  PyObject *dict;
1547 #endif
1548 } SwigPyObject;
1549 
1550 
1551 #ifdef SWIGPYTHON_BUILTIN
1552 
1553 SWIGRUNTIME PyObject *
1554 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1555 {
1556  SwigPyObject *sobj = (SwigPyObject *)v;
1557 
1558  if (!sobj->dict)
1559  sobj->dict = PyDict_New();
1560 
1561  Py_INCREF(sobj->dict);
1562  return sobj->dict;
1563 }
1564 
1565 #endif
1566 
1567 SWIGRUNTIME PyObject *
1568 SwigPyObject_long(SwigPyObject *v)
1569 {
1570  return PyLong_FromVoidPtr(v->ptr);
1571 }
1572 
1573 SWIGRUNTIME PyObject *
1574 SwigPyObject_format(const char* fmt, SwigPyObject *v)
1575 {
1576  PyObject *res = NULL;
1577  PyObject *args = PyTuple_New(1);
1578  if (args) {
1579  if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1580  PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1581  if (ofmt) {
1582 #if PY_VERSION_HEX >= 0x03000000
1583  res = PyUnicode_Format(ofmt,args);
1584 #else
1585  res = PyString_Format(ofmt,args);
1586 #endif
1587  Py_DECREF(ofmt);
1588  }
1589  Py_DECREF(args);
1590  }
1591  }
1592  return res;
1593 }
1594 
1595 SWIGRUNTIME PyObject *
1596 SwigPyObject_oct(SwigPyObject *v)
1597 {
1598  return SwigPyObject_format("%o",v);
1599 }
1600 
1601 SWIGRUNTIME PyObject *
1602 SwigPyObject_hex(SwigPyObject *v)
1603 {
1604  return SwigPyObject_format("%x",v);
1605 }
1606 
1607 SWIGRUNTIME PyObject *
1608 #ifdef METH_NOARGS
1609 SwigPyObject_repr(SwigPyObject *v)
1610 #else
1611 SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1612 #endif
1613 {
1614  const char *name = SWIG_TypePrettyName(v->ty);
1615  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1616  if (v->next) {
1617 # ifdef METH_NOARGS
1618  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1619 # else
1620  PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1621 # endif
1622 # if PY_VERSION_HEX >= 0x03000000
1623  PyObject *joined = PyUnicode_Concat(repr, nrep);
1624  Py_DecRef(repr);
1625  Py_DecRef(nrep);
1626  repr = joined;
1627 # else
1628  PyString_ConcatAndDel(&repr,nrep);
1629 # endif
1630  }
1631  return repr;
1632 }
1633 
1634 SWIGRUNTIME int
1635 SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1636 {
1637  void *i = v->ptr;
1638  void *j = w->ptr;
1639  return (i < j) ? -1 : ((i > j) ? 1 : 0);
1640 }
1641 
1642 /* Added for Python 3.x, would it also be useful for Python 2.x? */
1643 SWIGRUNTIME PyObject*
1644 SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1645 {
1646  PyObject* res;
1647  if( op != Py_EQ && op != Py_NE ) {
1648  Py_INCREF(Py_NotImplemented);
1649  return Py_NotImplemented;
1650  }
1651  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1652  return res;
1653 }
1654 
1655 
1656 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1657 
1658 #ifdef SWIGPYTHON_BUILTIN
1659 static swig_type_info *SwigPyObject_stype = 0;
1660 SWIGRUNTIME PyTypeObject*
1661 SwigPyObject_type(void) {
1662  SwigPyClientData *cd;
1663  assert(SwigPyObject_stype);
1664  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1665  assert(cd);
1666  assert(cd->pytype);
1667  return cd->pytype;
1668 }
1669 #else
1670 SWIGRUNTIME PyTypeObject*
1671 SwigPyObject_type(void) {
1672  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1673  return type;
1674 }
1675 #endif
1676 
1677 SWIGRUNTIMEINLINE int
1678 SwigPyObject_Check(PyObject *op) {
1679 #ifdef SWIGPYTHON_BUILTIN
1680  PyTypeObject *target_tp = SwigPyObject_type();
1681  if (PyType_IsSubtype(op->ob_type, target_tp))
1682  return 1;
1683  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1684 #else
1685  return (Py_TYPE(op) == SwigPyObject_type())
1686  || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1687 #endif
1688 }
1689 
1690 SWIGRUNTIME PyObject *
1691 SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1692 
1693 SWIGRUNTIME void
1694 SwigPyObject_dealloc(PyObject *v)
1695 {
1696  SwigPyObject *sobj = (SwigPyObject *) v;
1697  PyObject *next = sobj->next;
1698  if (sobj->own == SWIG_POINTER_OWN) {
1699  swig_type_info *ty = sobj->ty;
1700  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1701  PyObject *destroy = data ? data->destroy : 0;
1702  if (destroy) {
1703  /* destroy is always a VARARGS method */
1704  PyObject *res;
1705 
1706  /* PyObject_CallFunction() has the potential to silently drop
1707  the active active exception. In cases of unnamed temporary
1708  variable or where we just finished iterating over a generator
1709  StopIteration will be active right now, and this needs to
1710  remain true upon return from SwigPyObject_dealloc. So save
1711  and restore. */
1712 
1713  PyObject *val = NULL, *type = NULL, *tb = NULL;
1714  PyErr_Fetch(&val, &type, &tb);
1715 
1716  if (data->delargs) {
1717  /* we need to create a temporary object to carry the destroy operation */
1718  PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1719  res = SWIG_Python_CallFunctor(destroy, tmp);
1720  Py_DECREF(tmp);
1721  } else {
1722  PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1723  PyObject *mself = PyCFunction_GET_SELF(destroy);
1724  res = ((*meth)(mself, v));
1725  }
1726  if (!res)
1727  PyErr_WriteUnraisable(destroy);
1728 
1729  PyErr_Restore(val, type, tb);
1730 
1731  Py_XDECREF(res);
1732  }
1733 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1734  else {
1735  const char *name = SWIG_TypePrettyName(ty);
1736  printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1737  }
1738 #endif
1739  }
1740  Py_XDECREF(next);
1741  PyObject_DEL(v);
1742 }
1743 
1744 SWIGRUNTIME PyObject*
1745 SwigPyObject_append(PyObject* v, PyObject* next)
1746 {
1747  SwigPyObject *sobj = (SwigPyObject *) v;
1748 #ifndef METH_O
1749  PyObject *tmp = 0;
1750  if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1751  next = tmp;
1752 #endif
1753  if (!SwigPyObject_Check(next)) {
1754  PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1755  return NULL;
1756  }
1757  sobj->next = next;
1758  Py_INCREF(next);
1759  return SWIG_Py_Void();
1760 }
1761 
1762 SWIGRUNTIME PyObject*
1763 #ifdef METH_NOARGS
1764 SwigPyObject_next(PyObject* v)
1765 #else
1766 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1767 #endif
1768 {
1769  SwigPyObject *sobj = (SwigPyObject *) v;
1770  if (sobj->next) {
1771  Py_INCREF(sobj->next);
1772  return sobj->next;
1773  } else {
1774  return SWIG_Py_Void();
1775  }
1776 }
1777 
1778 SWIGINTERN PyObject*
1779 #ifdef METH_NOARGS
1780 SwigPyObject_disown(PyObject *v)
1781 #else
1782 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1783 #endif
1784 {
1785  SwigPyObject *sobj = (SwigPyObject *)v;
1786  sobj->own = 0;
1787  return SWIG_Py_Void();
1788 }
1789 
1790 SWIGINTERN PyObject*
1791 #ifdef METH_NOARGS
1792 SwigPyObject_acquire(PyObject *v)
1793 #else
1794 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1795 #endif
1796 {
1797  SwigPyObject *sobj = (SwigPyObject *)v;
1798  sobj->own = SWIG_POINTER_OWN;
1799  return SWIG_Py_Void();
1800 }
1801 
1802 SWIGINTERN PyObject*
1803 SwigPyObject_own(PyObject *v, PyObject *args)
1804 {
1805  PyObject *val = 0;
1806 #if (PY_VERSION_HEX < 0x02020000)
1807  if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1808 #elif (PY_VERSION_HEX < 0x02050000)
1809  if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1810 #else
1811  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1812 #endif
1813  {
1814  return NULL;
1815  }
1816  else
1817  {
1818  SwigPyObject *sobj = (SwigPyObject *)v;
1819  PyObject *obj = PyBool_FromLong(sobj->own);
1820  if (val) {
1821 #ifdef METH_NOARGS
1822  if (PyObject_IsTrue(val)) {
1823  SwigPyObject_acquire(v);
1824  } else {
1825  SwigPyObject_disown(v);
1826  }
1827 #else
1828  if (PyObject_IsTrue(val)) {
1829  SwigPyObject_acquire(v,args);
1830  } else {
1831  SwigPyObject_disown(v,args);
1832  }
1833 #endif
1834  }
1835  return obj;
1836  }
1837 }
1838 
1839 #ifdef METH_O
1840 static PyMethodDef
1841 swigobject_methods[] = {
1842  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1843  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1844  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1845  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1846  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1847  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1848  {0, 0, 0, 0}
1849 };
1850 #else
1851 static PyMethodDef
1852 swigobject_methods[] = {
1853  {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1854  {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"},
1855  {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1856  {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1857  {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1858  {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1859  {0, 0, 0, 0}
1860 };
1861 #endif
1862 
1863 #if PY_VERSION_HEX < 0x02020000
1864 SWIGINTERN PyObject *
1865 SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1866 {
1867  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1868 }
1869 #endif
1870 
1871 SWIGRUNTIME PyTypeObject*
1872 SwigPyObject_TypeOnce(void) {
1873  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1874 
1875  static PyNumberMethods SwigPyObject_as_number = {
1876  (binaryfunc)0, /*nb_add*/
1877  (binaryfunc)0, /*nb_subtract*/
1878  (binaryfunc)0, /*nb_multiply*/
1879  /* nb_divide removed in Python 3 */
1880 #if PY_VERSION_HEX < 0x03000000
1881  (binaryfunc)0, /*nb_divide*/
1882 #endif
1883  (binaryfunc)0, /*nb_remainder*/
1884  (binaryfunc)0, /*nb_divmod*/
1885  (ternaryfunc)0,/*nb_power*/
1886  (unaryfunc)0, /*nb_negative*/
1887  (unaryfunc)0, /*nb_positive*/
1888  (unaryfunc)0, /*nb_absolute*/
1889  (inquiry)0, /*nb_nonzero*/
1890  0, /*nb_invert*/
1891  0, /*nb_lshift*/
1892  0, /*nb_rshift*/
1893  0, /*nb_and*/
1894  0, /*nb_xor*/
1895  0, /*nb_or*/
1896 #if PY_VERSION_HEX < 0x03000000
1897  0, /*nb_coerce*/
1898 #endif
1899  (unaryfunc)SwigPyObject_long, /*nb_int*/
1900 #if PY_VERSION_HEX < 0x03000000
1901  (unaryfunc)SwigPyObject_long, /*nb_long*/
1902 #else
1903  0, /*nb_reserved*/
1904 #endif
1905  (unaryfunc)0, /*nb_float*/
1906 #if PY_VERSION_HEX < 0x03000000
1907  (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1908  (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1909 #endif
1910 #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1911  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1912 #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1913  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1914 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1915  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1916 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1917  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1918 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1919  0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1920 #endif
1921  };
1922 
1923  static PyTypeObject swigpyobject_type;
1924  static int type_init = 0;
1925  if (!type_init) {
1926  const PyTypeObject tmp = {
1927  /* PyObject header changed in Python 3 */
1928 #if PY_VERSION_HEX >= 0x03000000
1929  PyVarObject_HEAD_INIT(NULL, 0)
1930 #else
1931  PyObject_HEAD_INIT(NULL)
1932  0, /* ob_size */
1933 #endif
1934  (char *)"SwigPyObject", /* tp_name */
1935  sizeof(SwigPyObject), /* tp_basicsize */
1936  0, /* tp_itemsize */
1937  (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1938  0, /* tp_print */
1939 #if PY_VERSION_HEX < 0x02020000
1940  (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1941 #else
1942  (getattrfunc)0, /* tp_getattr */
1943 #endif
1944  (setattrfunc)0, /* tp_setattr */
1945 #if PY_VERSION_HEX >= 0x03000000
1946  0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1947 #else
1948  (cmpfunc)SwigPyObject_compare, /* tp_compare */
1949 #endif
1950  (reprfunc)SwigPyObject_repr, /* tp_repr */
1951  &SwigPyObject_as_number, /* tp_as_number */
1952  0, /* tp_as_sequence */
1953  0, /* tp_as_mapping */
1954  (hashfunc)0, /* tp_hash */
1955  (ternaryfunc)0, /* tp_call */
1956  0, /* tp_str */
1957  PyObject_GenericGetAttr, /* tp_getattro */
1958  0, /* tp_setattro */
1959  0, /* tp_as_buffer */
1960  Py_TPFLAGS_DEFAULT, /* tp_flags */
1961  swigobject_doc, /* tp_doc */
1962  0, /* tp_traverse */
1963  0, /* tp_clear */
1964  (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1965  0, /* tp_weaklistoffset */
1966 #if PY_VERSION_HEX >= 0x02020000
1967  0, /* tp_iter */
1968  0, /* tp_iternext */
1969  swigobject_methods, /* tp_methods */
1970  0, /* tp_members */
1971  0, /* tp_getset */
1972  0, /* tp_base */
1973  0, /* tp_dict */
1974  0, /* tp_descr_get */
1975  0, /* tp_descr_set */
1976  0, /* tp_dictoffset */
1977  0, /* tp_init */
1978  0, /* tp_alloc */
1979  0, /* tp_new */
1980  0, /* tp_free */
1981  0, /* tp_is_gc */
1982  0, /* tp_bases */
1983  0, /* tp_mro */
1984  0, /* tp_cache */
1985  0, /* tp_subclasses */
1986  0, /* tp_weaklist */
1987 #endif
1988 #if PY_VERSION_HEX >= 0x02030000
1989  0, /* tp_del */
1990 #endif
1991 #if PY_VERSION_HEX >= 0x02060000
1992  0, /* tp_version_tag */
1993 #endif
1994 #if PY_VERSION_HEX >= 0x03040000
1995  0, /* tp_finalize */
1996 #endif
1997 #ifdef COUNT_ALLOCS
1998  0, /* tp_allocs */
1999  0, /* tp_frees */
2000  0, /* tp_maxalloc */
2001 #if PY_VERSION_HEX >= 0x02050000
2002  0, /* tp_prev */
2003 #endif
2004  0 /* tp_next */
2005 #endif
2006  };
2007  swigpyobject_type = tmp;
2008  type_init = 1;
2009 #if PY_VERSION_HEX < 0x02020000
2010  swigpyobject_type.ob_type = &PyType_Type;
2011 #else
2012  if (PyType_Ready(&swigpyobject_type) < 0)
2013  return NULL;
2014 #endif
2015  }
2016  return &swigpyobject_type;
2017 }
2018 
2019 SWIGRUNTIME PyObject *
2020 SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2021 {
2022  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
2023  if (sobj) {
2024  sobj->ptr = ptr;
2025  sobj->ty = ty;
2026  sobj->own = own;
2027  sobj->next = 0;
2028  }
2029  return (PyObject *)sobj;
2030 }
2031 
2032 /* -----------------------------------------------------------------------------
2033  * Implements a simple Swig Packed type, and use it instead of string
2034  * ----------------------------------------------------------------------------- */
2035 
2036 typedef struct {
2037  PyObject_HEAD
2038  void *pack;
2039  swig_type_info *ty;
2040  size_t size;
2041 } SwigPyPacked;
2042 
2043 SWIGRUNTIME int
2044 SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
2045 {
2046  char result[SWIG_BUFFER_SIZE];
2047  fputs("<Swig Packed ", fp);
2048  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2049  fputs("at ", fp);
2050  fputs(result, fp);
2051  }
2052  fputs(v->ty->name,fp);
2053  fputs(">", fp);
2054  return 0;
2055 }
2056 
2057 SWIGRUNTIME PyObject *
2058 SwigPyPacked_repr(SwigPyPacked *v)
2059 {
2060  char result[SWIG_BUFFER_SIZE];
2061  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2062  return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2063  } else {
2064  return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2065  }
2066 }
2067 
2068 SWIGRUNTIME PyObject *
2069 SwigPyPacked_str(SwigPyPacked *v)
2070 {
2071  char result[SWIG_BUFFER_SIZE];
2072  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2073  return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2074  } else {
2075  return SWIG_Python_str_FromChar(v->ty->name);
2076  }
2077 }
2078 
2079 SWIGRUNTIME int
2080 SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2081 {
2082  size_t i = v->size;
2083  size_t j = w->size;
2084  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2085  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2086 }
2087 
2088 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2089 
2090 SWIGRUNTIME PyTypeObject*
2091 SwigPyPacked_type(void) {
2092  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2093  return type;
2094 }
2095 
2096 SWIGRUNTIMEINLINE int
2097 SwigPyPacked_Check(PyObject *op) {
2098  return ((op)->ob_type == SwigPyPacked_TypeOnce())
2099  || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2100 }
2101 
2102 SWIGRUNTIME void
2103 SwigPyPacked_dealloc(PyObject *v)
2104 {
2105  if (SwigPyPacked_Check(v)) {
2106  SwigPyPacked *sobj = (SwigPyPacked *) v;
2107  free(sobj->pack);
2108  }
2109  PyObject_DEL(v);
2110 }
2111 
2112 SWIGRUNTIME PyTypeObject*
2113 SwigPyPacked_TypeOnce(void) {
2114  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2115  static PyTypeObject swigpypacked_type;
2116  static int type_init = 0;
2117  if (!type_init) {
2118  const PyTypeObject tmp = {
2119  /* PyObject header changed in Python 3 */
2120 #if PY_VERSION_HEX>=0x03000000
2121  PyVarObject_HEAD_INIT(NULL, 0)
2122 #else
2123  PyObject_HEAD_INIT(NULL)
2124  0, /* ob_size */
2125 #endif
2126  (char *)"SwigPyPacked", /* tp_name */
2127  sizeof(SwigPyPacked), /* tp_basicsize */
2128  0, /* tp_itemsize */
2129  (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2130  (printfunc)SwigPyPacked_print, /* tp_print */
2131  (getattrfunc)0, /* tp_getattr */
2132  (setattrfunc)0, /* tp_setattr */
2133 #if PY_VERSION_HEX>=0x03000000
2134  0, /* tp_reserved in 3.0.1 */
2135 #else
2136  (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2137 #endif
2138  (reprfunc)SwigPyPacked_repr, /* tp_repr */
2139  0, /* tp_as_number */
2140  0, /* tp_as_sequence */
2141  0, /* tp_as_mapping */
2142  (hashfunc)0, /* tp_hash */
2143  (ternaryfunc)0, /* tp_call */
2144  (reprfunc)SwigPyPacked_str, /* tp_str */
2145  PyObject_GenericGetAttr, /* tp_getattro */
2146  0, /* tp_setattro */
2147  0, /* tp_as_buffer */
2148  Py_TPFLAGS_DEFAULT, /* tp_flags */
2149  swigpacked_doc, /* tp_doc */
2150  0, /* tp_traverse */
2151  0, /* tp_clear */
2152  0, /* tp_richcompare */
2153  0, /* tp_weaklistoffset */
2154 #if PY_VERSION_HEX >= 0x02020000
2155  0, /* tp_iter */
2156  0, /* tp_iternext */
2157  0, /* tp_methods */
2158  0, /* tp_members */
2159  0, /* tp_getset */
2160  0, /* tp_base */
2161  0, /* tp_dict */
2162  0, /* tp_descr_get */
2163  0, /* tp_descr_set */
2164  0, /* tp_dictoffset */
2165  0, /* tp_init */
2166  0, /* tp_alloc */
2167  0, /* tp_new */
2168  0, /* tp_free */
2169  0, /* tp_is_gc */
2170  0, /* tp_bases */
2171  0, /* tp_mro */
2172  0, /* tp_cache */
2173  0, /* tp_subclasses */
2174  0, /* tp_weaklist */
2175 #endif
2176 #if PY_VERSION_HEX >= 0x02030000
2177  0, /* tp_del */
2178 #endif
2179 #if PY_VERSION_HEX >= 0x02060000
2180  0, /* tp_version_tag */
2181 #endif
2182 #if PY_VERSION_HEX >= 0x03040000
2183  0, /* tp_finalize */
2184 #endif
2185 #ifdef COUNT_ALLOCS
2186  0, /* tp_allocs */
2187  0, /* tp_frees */
2188  0, /* tp_maxalloc */
2189 #if PY_VERSION_HEX >= 0x02050000
2190  0, /* tp_prev */
2191 #endif
2192  0 /* tp_next */
2193 #endif
2194  };
2195  swigpypacked_type = tmp;
2196  type_init = 1;
2197 #if PY_VERSION_HEX < 0x02020000
2198  swigpypacked_type.ob_type = &PyType_Type;
2199 #else
2200  if (PyType_Ready(&swigpypacked_type) < 0)
2201  return NULL;
2202 #endif
2203  }
2204  return &swigpypacked_type;
2205 }
2206 
2207 SWIGRUNTIME PyObject *
2208 SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2209 {
2210  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2211  if (sobj) {
2212  void *pack = malloc(size);
2213  if (pack) {
2214  memcpy(pack, ptr, size);
2215  sobj->pack = pack;
2216  sobj->ty = ty;
2217  sobj->size = size;
2218  } else {
2219  PyObject_DEL((PyObject *) sobj);
2220  sobj = 0;
2221  }
2222  }
2223  return (PyObject *) sobj;
2224 }
2225 
2226 SWIGRUNTIME swig_type_info *
2227 SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2228 {
2229  if (SwigPyPacked_Check(obj)) {
2230  SwigPyPacked *sobj = (SwigPyPacked *)obj;
2231  if (sobj->size != size) return 0;
2232  memcpy(ptr, sobj->pack, size);
2233  return sobj->ty;
2234  } else {
2235  return 0;
2236  }
2237 }
2238 
2239 /* -----------------------------------------------------------------------------
2240  * pointers/data manipulation
2241  * ----------------------------------------------------------------------------- */
2242 
2243 SWIGRUNTIMEINLINE PyObject *
2244 _SWIG_This(void)
2245 {
2246  return SWIG_Python_str_FromChar("this");
2247 }
2248 
2249 static PyObject *swig_this = NULL;
2250 
2251 SWIGRUNTIME PyObject *
2252 SWIG_This(void)
2253 {
2254  if (swig_this == NULL)
2255  swig_this = _SWIG_This();
2256  return swig_this;
2257 }
2258 
2259 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2260 
2261 /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2262 #if PY_VERSION_HEX>=0x03000000
2263 #define SWIG_PYTHON_SLOW_GETSET_THIS
2264 #endif
2265 
2266 SWIGRUNTIME SwigPyObject *
2267 SWIG_Python_GetSwigThis(PyObject *pyobj)
2268 {
2269  PyObject *obj;
2270 
2271  if (SwigPyObject_Check(pyobj))
2272  return (SwigPyObject *) pyobj;
2273 
2274 #ifdef SWIGPYTHON_BUILTIN
2275  (void)obj;
2276 # ifdef PyWeakref_CheckProxy
2277  if (PyWeakref_CheckProxy(pyobj)) {
2278  pyobj = PyWeakref_GET_OBJECT(pyobj);
2279  if (pyobj && SwigPyObject_Check(pyobj))
2280  return (SwigPyObject*) pyobj;
2281  }
2282 # endif
2283  return NULL;
2284 #else
2285 
2286  obj = 0;
2287 
2288 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2289  if (PyInstance_Check(pyobj)) {
2290  obj = _PyInstance_Lookup(pyobj, SWIG_This());
2291  } else {
2292  PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2293  if (dictptr != NULL) {
2294  PyObject *dict = *dictptr;
2295  obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2296  } else {
2297 #ifdef PyWeakref_CheckProxy
2298  if (PyWeakref_CheckProxy(pyobj)) {
2299  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2300  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2301  }
2302 #endif
2303  obj = PyObject_GetAttr(pyobj,SWIG_This());
2304  if (obj) {
2305  Py_DECREF(obj);
2306  } else {
2307  if (PyErr_Occurred()) PyErr_Clear();
2308  return 0;
2309  }
2310  }
2311  }
2312 #else
2313  obj = PyObject_GetAttr(pyobj,SWIG_This());
2314  if (obj) {
2315  Py_DECREF(obj);
2316  } else {
2317  if (PyErr_Occurred()) PyErr_Clear();
2318  return 0;
2319  }
2320 #endif
2321  if (obj && !SwigPyObject_Check(obj)) {
2322  /* a PyObject is called 'this', try to get the 'real this'
2323  SwigPyObject from it */
2324  return SWIG_Python_GetSwigThis(obj);
2325  }
2326  return (SwigPyObject *)obj;
2327 #endif
2328 }
2329 
2330 /* Acquire a pointer value */
2331 
2332 SWIGRUNTIME int
2333 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2334  if (own == SWIG_POINTER_OWN) {
2335  SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2336  if (sobj) {
2337  int oldown = sobj->own;
2338  sobj->own = own;
2339  return oldown;
2340  }
2341  }
2342  return 0;
2343 }
2344 
2345 /* Convert a pointer value */
2346 
2347 SWIGRUNTIME int
2348 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2349  int res;
2350  SwigPyObject *sobj;
2351  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2352 
2353  if (!obj)
2354  return SWIG_ERROR;
2355  if (obj == Py_None && !implicit_conv) {
2356  if (ptr)
2357  *ptr = 0;
2358  return SWIG_OK;
2359  }
2360 
2361  res = SWIG_ERROR;
2362 
2363  sobj = SWIG_Python_GetSwigThis(obj);
2364  if (own)
2365  *own = 0;
2366  while (sobj) {
2367  void *vptr = sobj->ptr;
2368  if (ty) {
2369  swig_type_info *to = sobj->ty;
2370  if (to == ty) {
2371  /* no type cast needed */
2372  if (ptr) *ptr = vptr;
2373  break;
2374  } else {
2375  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2376  if (!tc) {
2377  sobj = (SwigPyObject *)sobj->next;
2378  } else {
2379  if (ptr) {
2380  int newmemory = 0;
2381  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2382  if (newmemory == SWIG_CAST_NEW_MEMORY) {
2383  assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2384  if (own)
2385  *own = *own | SWIG_CAST_NEW_MEMORY;
2386  }
2387  }
2388  break;
2389  }
2390  }
2391  } else {
2392  if (ptr) *ptr = vptr;
2393  break;
2394  }
2395  }
2396  if (sobj) {
2397  if (own)
2398  *own = *own | sobj->own;
2399  if (flags & SWIG_POINTER_DISOWN) {
2400  sobj->own = 0;
2401  }
2402  res = SWIG_OK;
2403  } else {
2404  if (implicit_conv) {
2405  SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2406  if (data && !data->implicitconv) {
2407  PyObject *klass = data->klass;
2408  if (klass) {
2409  PyObject *impconv;
2410  data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2411  impconv = SWIG_Python_CallFunctor(klass, obj);
2412  data->implicitconv = 0;
2413  if (PyErr_Occurred()) {
2414  PyErr_Clear();
2415  impconv = 0;
2416  }
2417  if (impconv) {
2418  SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2419  if (iobj) {
2420  void *vptr;
2421  res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2422  if (SWIG_IsOK(res)) {
2423  if (ptr) {
2424  *ptr = vptr;
2425  /* transfer the ownership to 'ptr' */
2426  iobj->own = 0;
2427  res = SWIG_AddCast(res);
2428  res = SWIG_AddNewMask(res);
2429  } else {
2430  res = SWIG_AddCast(res);
2431  }
2432  }
2433  }
2434  Py_DECREF(impconv);
2435  }
2436  }
2437  }
2438  }
2439  if (!SWIG_IsOK(res) && obj == Py_None) {
2440  if (ptr)
2441  *ptr = 0;
2442  if (PyErr_Occurred())
2443  PyErr_Clear();
2444  res = SWIG_OK;
2445  }
2446  }
2447  return res;
2448 }
2449 
2450 /* Convert a function ptr value */
2451 
2452 SWIGRUNTIME int
2453 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2454  if (!PyCFunction_Check(obj)) {
2455  return SWIG_ConvertPtr(obj, ptr, ty, 0);
2456  } else {
2457  void *vptr = 0;
2458 
2459  /* here we get the method pointer for callbacks */
2460  const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2461  const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2462  if (desc)
2463  desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2464  if (!desc)
2465  return SWIG_ERROR;
2466  if (ty) {
2467  swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2468  if (tc) {
2469  int newmemory = 0;
2470  *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2471  assert(!newmemory); /* newmemory handling not yet implemented */
2472  } else {
2473  return SWIG_ERROR;
2474  }
2475  } else {
2476  *ptr = vptr;
2477  }
2478  return SWIG_OK;
2479  }
2480 }
2481 
2482 /* Convert a packed value value */
2483 
2484 SWIGRUNTIME int
2485 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2486  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2487  if (!to) return SWIG_ERROR;
2488  if (ty) {
2489  if (to != ty) {
2490  /* check type cast? */
2491  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2492  if (!tc) return SWIG_ERROR;
2493  }
2494  }
2495  return SWIG_OK;
2496 }
2497 
2498 /* -----------------------------------------------------------------------------
2499  * Create a new pointer object
2500  * ----------------------------------------------------------------------------- */
2501 
2502 /*
2503  Create a new instance object, without calling __init__, and set the
2504  'this' attribute.
2505 */
2506 
2507 SWIGRUNTIME PyObject*
2508 SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2509 {
2510 #if (PY_VERSION_HEX >= 0x02020000)
2511  PyObject *inst = 0;
2512  PyObject *newraw = data->newraw;
2513  if (newraw) {
2514  inst = PyObject_Call(newraw, data->newargs, NULL);
2515  if (inst) {
2516 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2517  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2518  if (dictptr != NULL) {
2519  PyObject *dict = *dictptr;
2520  if (dict == NULL) {
2521  dict = PyDict_New();
2522  *dictptr = dict;
2523  PyDict_SetItem(dict, SWIG_This(), swig_this);
2524  }
2525  }
2526 #else
2527  PyObject *key = SWIG_This();
2528  PyObject_SetAttr(inst, key, swig_this);
2529 #endif
2530  }
2531  } else {
2532 #if PY_VERSION_HEX >= 0x03000000
2533  inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2534  if (inst) {
2535  PyObject_SetAttr(inst, SWIG_This(), swig_this);
2536  Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2537  }
2538 #else
2539  PyObject *dict = PyDict_New();
2540  if (dict) {
2541  PyDict_SetItem(dict, SWIG_This(), swig_this);
2542  inst = PyInstance_NewRaw(data->newargs, dict);
2543  Py_DECREF(dict);
2544  }
2545 #endif
2546  }
2547  return inst;
2548 #else
2549 #if (PY_VERSION_HEX >= 0x02010000)
2550  PyObject *inst = 0;
2551  PyObject *dict = PyDict_New();
2552  if (dict) {
2553  PyDict_SetItem(dict, SWIG_This(), swig_this);
2554  inst = PyInstance_NewRaw(data->newargs, dict);
2555  Py_DECREF(dict);
2556  }
2557  return (PyObject *) inst;
2558 #else
2559  PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2560  if (inst == NULL) {
2561  return NULL;
2562  }
2563  inst->in_class = (PyClassObject *)data->newargs;
2564  Py_INCREF(inst->in_class);
2565  inst->in_dict = PyDict_New();
2566  if (inst->in_dict == NULL) {
2567  Py_DECREF(inst);
2568  return NULL;
2569  }
2570 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2571  inst->in_weakreflist = NULL;
2572 #endif
2573 #ifdef Py_TPFLAGS_GC
2574  PyObject_GC_Init(inst);
2575 #endif
2576  PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2577  return (PyObject *) inst;
2578 #endif
2579 #endif
2580 }
2581 
2582 SWIGRUNTIME void
2583 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2584 {
2585  PyObject *dict;
2586 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2587  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2588  if (dictptr != NULL) {
2589  dict = *dictptr;
2590  if (dict == NULL) {
2591  dict = PyDict_New();
2592  *dictptr = dict;
2593  }
2594  PyDict_SetItem(dict, SWIG_This(), swig_this);
2595  return;
2596  }
2597 #endif
2598  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2599  PyDict_SetItem(dict, SWIG_This(), swig_this);
2600  Py_DECREF(dict);
2601 }
2602 
2603 
2604 SWIGINTERN PyObject *
2605 SWIG_Python_InitShadowInstance(PyObject *args) {
2606  PyObject *obj[2];
2607  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2608  return NULL;
2609  } else {
2610  SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2611  if (sthis) {
2612  SwigPyObject_append((PyObject*) sthis, obj[1]);
2613  } else {
2614  SWIG_Python_SetSwigThis(obj[0], obj[1]);
2615  }
2616  return SWIG_Py_Void();
2617  }
2618 }
2619 
2620 /* Create a new pointer object */
2621 
2622 SWIGRUNTIME PyObject *
2623 SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2624  SwigPyClientData *clientdata;
2625  PyObject * robj;
2626  int own;
2627 
2628  if (!ptr)
2629  return SWIG_Py_Void();
2630 
2631  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2632  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2633  if (clientdata && clientdata->pytype) {
2634  SwigPyObject *newobj;
2635  if (flags & SWIG_BUILTIN_TP_INIT) {
2636  newobj = (SwigPyObject*) self;
2637  if (newobj->ptr) {
2638  PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2639  while (newobj->next)
2640  newobj = (SwigPyObject *) newobj->next;
2641  newobj->next = next_self;
2642  newobj = (SwigPyObject *)next_self;
2643 #ifdef SWIGPYTHON_BUILTIN
2644  newobj->dict = 0;
2645 #endif
2646  }
2647  } else {
2648  newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2649 #ifdef SWIGPYTHON_BUILTIN
2650  newobj->dict = 0;
2651 #endif
2652  }
2653  if (newobj) {
2654  newobj->ptr = ptr;
2655  newobj->ty = type;
2656  newobj->own = own;
2657  newobj->next = 0;
2658  return (PyObject*) newobj;
2659  }
2660  return SWIG_Py_Void();
2661  }
2662 
2663  assert(!(flags & SWIG_BUILTIN_TP_INIT));
2664 
2665  robj = SwigPyObject_New(ptr, type, own);
2666  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2667  PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2668  Py_DECREF(robj);
2669  robj = inst;
2670  }
2671  return robj;
2672 }
2673 
2674 /* Create a new packed object */
2675 
2676 SWIGRUNTIMEINLINE PyObject *
2677 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2678  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2679 }
2680 
2681 /* -----------------------------------------------------------------------------*
2682  * Get type list
2683  * -----------------------------------------------------------------------------*/
2684 
2685 #ifdef SWIG_LINK_RUNTIME
2686 void *SWIG_ReturnGlobalTypeList(void *);
2687 #endif
2688 
2689 SWIGRUNTIME swig_module_info *
2690 SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2691  static void *type_pointer = (void *)0;
2692  /* first check if module already created */
2693  if (!type_pointer) {
2694 #ifdef SWIG_LINK_RUNTIME
2695  type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2696 #else
2697 # ifdef SWIGPY_USE_CAPSULE
2698  type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2699 # else
2700  type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2701  (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2702 # endif
2703  if (PyErr_Occurred()) {
2704  PyErr_Clear();
2705  type_pointer = (void *)0;
2706  }
2707 #endif
2708  }
2709  return (swig_module_info *) type_pointer;
2710 }
2711 
2712 #if PY_MAJOR_VERSION < 2
2713 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2714  is copied out of Python/modsupport.c in python version 2.3.4 */
2715 SWIGINTERN int
2716 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2717 {
2718  PyObject *dict;
2719  if (!PyModule_Check(m)) {
2720  PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
2721  return SWIG_ERROR;
2722  }
2723  if (!o) {
2724  PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
2725  return SWIG_ERROR;
2726  }
2727 
2728  dict = PyModule_GetDict(m);
2729  if (dict == NULL) {
2730  /* Internal error -- modules must have a dict! */
2731  PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2732  PyModule_GetName(m));
2733  return SWIG_ERROR;
2734  }
2735  if (PyDict_SetItemString(dict, name, o))
2736  return SWIG_ERROR;
2737  Py_DECREF(o);
2738  return SWIG_OK;
2739 }
2740 #endif
2741 
2742 SWIGRUNTIME void
2743 #ifdef SWIGPY_USE_CAPSULE
2744 SWIG_Python_DestroyModule(PyObject *obj)
2745 #else
2746 SWIG_Python_DestroyModule(void *vptr)
2747 #endif
2748 {
2749 #ifdef SWIGPY_USE_CAPSULE
2750  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2751 #else
2752  swig_module_info *swig_module = (swig_module_info *) vptr;
2753 #endif
2754  swig_type_info **types = swig_module->types;
2755  size_t i;
2756  for (i =0; i < swig_module->size; ++i) {
2757  swig_type_info *ty = types[i];
2758  if (ty->owndata) {
2759  SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2760  if (data) SwigPyClientData_Del(data);
2761  }
2762  }
2763  Py_DECREF(SWIG_This());
2764  swig_this = NULL;
2765 }
2766 
2767 SWIGRUNTIME void
2768 SWIG_Python_SetModule(swig_module_info *swig_module) {
2769 #if PY_VERSION_HEX >= 0x03000000
2770  /* Add a dummy module object into sys.modules */
2771  PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2772 #else
2773  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2774  PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2775 #endif
2776 #ifdef SWIGPY_USE_CAPSULE
2777  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2778  if (pointer && module) {
2779  PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2780  } else {
2781  Py_XDECREF(pointer);
2782  }
2783 #else
2784  PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2785  if (pointer && module) {
2786  PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2787  } else {
2788  Py_XDECREF(pointer);
2789  }
2790 #endif
2791 }
2792 
2793 /* The python cached type query */
2794 SWIGRUNTIME PyObject *
2795 SWIG_Python_TypeCache(void) {
2796  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2797  return cache;
2798 }
2799 
2800 SWIGRUNTIME swig_type_info *
2801 SWIG_Python_TypeQuery(const char *type)
2802 {
2803  PyObject *cache = SWIG_Python_TypeCache();
2804  PyObject *key = SWIG_Python_str_FromChar(type);
2805  PyObject *obj = PyDict_GetItem(cache, key);
2806  swig_type_info *descriptor;
2807  if (obj) {
2808 #ifdef SWIGPY_USE_CAPSULE
2809  descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2810 #else
2811  descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2812 #endif
2813  } else {
2814  swig_module_info *swig_module = SWIG_GetModule(0);
2815  descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2816  if (descriptor) {
2817 #ifdef SWIGPY_USE_CAPSULE
2818  obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2819 #else
2820  obj = PyCObject_FromVoidPtr(descriptor, NULL);
2821 #endif
2822  PyDict_SetItem(cache, key, obj);
2823  Py_DECREF(obj);
2824  }
2825  }
2826  Py_DECREF(key);
2827  return descriptor;
2828 }
2829 
2830 /*
2831  For backward compatibility only
2832 */
2833 #define SWIG_POINTER_EXCEPTION 0
2834 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2835 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2836 
2837 SWIGRUNTIME int
2838 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2839 {
2840  if (PyErr_Occurred()) {
2841  PyObject *type = 0;
2842  PyObject *value = 0;
2843  PyObject *traceback = 0;
2844  PyErr_Fetch(&type, &value, &traceback);
2845  if (value) {
2846  char *tmp;
2847  PyObject *old_str = PyObject_Str(value);
2848  Py_XINCREF(type);
2849  PyErr_Clear();
2850  if (infront) {
2851  PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2852  } else {
2853  PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2854  }
2855  SWIG_Python_str_DelForPy3(tmp);
2856  Py_DECREF(old_str);
2857  }
2858  return 1;
2859  } else {
2860  return 0;
2861  }
2862 }
2863 
2864 SWIGRUNTIME int
2865 SWIG_Python_ArgFail(int argnum)
2866 {
2867  if (PyErr_Occurred()) {
2868  /* add information about failing argument */
2869  char mesg[256];
2870  PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2871  return SWIG_Python_AddErrMesg(mesg, 1);
2872  } else {
2873  return 0;
2874  }
2875 }
2876 
2877 SWIGRUNTIMEINLINE const char *
2878 SwigPyObject_GetDesc(PyObject *self)
2879 {
2880  SwigPyObject *v = (SwigPyObject *)self;
2881  swig_type_info *ty = v ? v->ty : 0;
2882  return ty ? ty->str : "";
2883 }
2884 
2885 SWIGRUNTIME void
2886 SWIG_Python_TypeError(const char *type, PyObject *obj)
2887 {
2888  if (type) {
2889 #if defined(SWIG_COBJECT_TYPES)
2890  if (obj && SwigPyObject_Check(obj)) {
2891  const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2892  if (otype) {
2893  PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2894  type, otype);
2895  return;
2896  }
2897  } else
2898 #endif
2899  {
2900  const char *otype = (obj ? obj->ob_type->tp_name : 0);
2901  if (otype) {
2902  PyObject *str = PyObject_Str(obj);
2903  const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2904  if (cstr) {
2905  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2906  type, otype, cstr);
2907  SWIG_Python_str_DelForPy3(cstr);
2908  } else {
2909  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2910  type, otype);
2911  }
2912  Py_XDECREF(str);
2913  return;
2914  }
2915  }
2916  PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2917  } else {
2918  PyErr_Format(PyExc_TypeError, "unexpected type is received");
2919  }
2920 }
2921 
2922 
2923 /* Convert a pointer value, signal an exception on a type mismatch */
2924 SWIGRUNTIME void *
2925 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2926  void *result;
2927  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2928  PyErr_Clear();
2929 #if SWIG_POINTER_EXCEPTION
2930  if (flags) {
2931  SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2932  SWIG_Python_ArgFail(argnum);
2933  }
2934 #endif
2935  }
2936  return result;
2937 }
2938 
2939 #ifdef SWIGPYTHON_BUILTIN
2940 SWIGRUNTIME int
2941 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2942  PyTypeObject *tp = obj->ob_type;
2943  PyObject *descr;
2944  PyObject *encoded_name;
2945  descrsetfunc f;
2946  int res = -1;
2947 
2948 # ifdef Py_USING_UNICODE
2949  if (PyString_Check(name)) {
2950  name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2951  if (!name)
2952  return -1;
2953  } else if (!PyUnicode_Check(name))
2954 # else
2955  if (!PyString_Check(name))
2956 # endif
2957  {
2958  PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2959  return -1;
2960  } else {
2961  Py_INCREF(name);
2962  }
2963 
2964  if (!tp->tp_dict) {
2965  if (PyType_Ready(tp) < 0)
2966  goto done;
2967  }
2968 
2969  descr = _PyType_Lookup(tp, name);
2970  f = NULL;
2971  if (descr != NULL)
2972  f = descr->ob_type->tp_descr_set;
2973  if (!f) {
2974  if (PyString_Check(name)) {
2975  encoded_name = name;
2976  Py_INCREF(name);
2977  } else {
2978  encoded_name = PyUnicode_AsUTF8String(name);
2979  }
2980  PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2981  Py_DECREF(encoded_name);
2982  } else {
2983  res = f(descr, obj, value);
2984  }
2985 
2986  done:
2987  Py_DECREF(name);
2988  return res;
2989 }
2990 #endif
2991 
2992 
2993 #ifdef __cplusplus
2994 }
2995 #endif
2996 
2997 
2998 
2999 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3000 
3001 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
3002 
3003 
3004 
3005 /* -------- TYPES TABLE (BEGIN) -------- */
3006 
3007 #define SWIGTYPE_p_Afi swig_types[0]
3008 #define SWIGTYPE_p_BgpOutHandler swig_types[1]
3009 #define SWIGTYPE_p_BgpRib4 swig_types[2]
3010 #define SWIGTYPE_p_BgpRib6 swig_types[3]
3011 #define SWIGTYPE_p_Clock swig_types[4]
3012 #define SWIGTYPE_p_char swig_types[5]
3013 #define SWIGTYPE_p_int swig_types[6]
3014 #define SWIGTYPE_p_libbgp__BgpAsPathSegment swig_types[7]
3015 #define SWIGTYPE_p_libbgp__BgpBadMessage swig_types[8]
3016 #define SWIGTYPE_p_libbgp__BgpCapability swig_types[9]
3017 #define SWIGTYPE_p_libbgp__BgpCapability4BytesAsn swig_types[10]
3018 #define SWIGTYPE_p_libbgp__BgpCapabilityMpBgp swig_types[11]
3019 #define SWIGTYPE_p_libbgp__BgpCapabilityUnknow swig_types[12]
3020 #define SWIGTYPE_p_libbgp__BgpConfig swig_types[13]
3021 #define SWIGTYPE_p_libbgp__BgpFilterRule swig_types[14]
3022 #define SWIGTYPE_p_libbgp__BgpFilterRuleAsPath swig_types[15]
3023 #define SWIGTYPE_p_libbgp__BgpFilterRuleCommunity swig_types[16]
3024 #define SWIGTYPE_p_libbgp__BgpFilterRuleRoute4 swig_types[17]
3025 #define SWIGTYPE_p_libbgp__BgpFilterRuleRoute6 swig_types[18]
3026 #define SWIGTYPE_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t swig_types[19]
3027 #define SWIGTYPE_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t swig_types[20]
3028 #define SWIGTYPE_p_libbgp__BgpFilterRules swig_types[21]
3029 #define SWIGTYPE_p_libbgp__BgpFsm swig_types[22]
3030 #define SWIGTYPE_p_libbgp__BgpKeepaliveMessage swig_types[23]
3031 #define SWIGTYPE_p_libbgp__BgpLogHandler swig_types[24]
3032 #define SWIGTYPE_p_libbgp__BgpMessage swig_types[25]
3033 #define SWIGTYPE_p_libbgp__BgpNotificationMessage swig_types[26]
3034 #define SWIGTYPE_p_libbgp__BgpOpenMessage swig_types[27]
3035 #define SWIGTYPE_p_libbgp__BgpOutHandler swig_types[28]
3036 #define SWIGTYPE_p_libbgp__BgpPacket swig_types[29]
3037 #define SWIGTYPE_p_libbgp__BgpPathAttrib swig_types[30]
3038 #define SWIGTYPE_p_libbgp__BgpPathAttribAggregator swig_types[31]
3039 #define SWIGTYPE_p_libbgp__BgpPathAttribAs4Aggregator swig_types[32]
3040 #define SWIGTYPE_p_libbgp__BgpPathAttribAs4Path swig_types[33]
3041 #define SWIGTYPE_p_libbgp__BgpPathAttribAsPath swig_types[34]
3042 #define SWIGTYPE_p_libbgp__BgpPathAttribAtomicAggregate swig_types[35]
3043 #define SWIGTYPE_p_libbgp__BgpPathAttribCommunity swig_types[36]
3044 #define SWIGTYPE_p_libbgp__BgpPathAttribLocalPref swig_types[37]
3045 #define SWIGTYPE_p_libbgp__BgpPathAttribMed swig_types[38]
3046 #define SWIGTYPE_p_libbgp__BgpPathAttribMpNlriBase swig_types[39]
3047 #define SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6 swig_types[40]
3048 #define SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriUnknow swig_types[41]
3049 #define SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriIpv6 swig_types[42]
3050 #define SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriUnknow swig_types[43]
3051 #define SWIGTYPE_p_libbgp__BgpPathAttribNexthop swig_types[44]
3052 #define SWIGTYPE_p_libbgp__BgpPathAttribOrigin swig_types[45]
3053 #define SWIGTYPE_p_libbgp__BgpRib4 swig_types[46]
3054 #define SWIGTYPE_p_libbgp__BgpRib4Entry swig_types[47]
3055 #define SWIGTYPE_p_libbgp__BgpRib6 swig_types[48]
3056 #define SWIGTYPE_p_libbgp__BgpRib6Entry swig_types[49]
3057 #define SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t swig_types[50]
3058 #define SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t swig_types[51]
3059 #define SWIGTYPE_p_libbgp__BgpSink swig_types[52]
3060 #define SWIGTYPE_p_libbgp__BgpUpdateMessage swig_types[53]
3061 #define SWIGTYPE_p_libbgp__Clock swig_types[54]
3062 #define SWIGTYPE_p_libbgp__FdOutHandler swig_types[55]
3063 #define SWIGTYPE_p_libbgp__Prefix swig_types[56]
3064 #define SWIGTYPE_p_libbgp__Prefix4 swig_types[57]
3065 #define SWIGTYPE_p_libbgp__Prefix6 swig_types[58]
3066 #define SWIGTYPE_p_libbgp__RealtimeClock swig_types[59]
3067 #define SWIGTYPE_p_libbgp__Route4AddEvent swig_types[60]
3068 #define SWIGTYPE_p_libbgp__Route4WithdrawEvent swig_types[61]
3069 #define SWIGTYPE_p_libbgp__Route6AddEvent swig_types[62]
3070 #define SWIGTYPE_p_libbgp__Route6WithdrawEvent swig_types[63]
3071 #define SWIGTYPE_p_libbgp__RouteCollisionEvent swig_types[64]
3072 #define SWIGTYPE_p_libbgp__RouteEvent swig_types[65]
3073 #define SWIGTYPE_p_libbgp__RouteEventBus swig_types[66]
3074 #define SWIGTYPE_p_libbgp__RouteEventReceiver swig_types[67]
3075 #define SWIGTYPE_p_libbgp__Serializable swig_types[68]
3076 #define SWIGTYPE_p_long_long swig_types[69]
3077 #define SWIGTYPE_p_p_char swig_types[70]
3078 #define SWIGTYPE_p_p_libbgp__BgpPacket swig_types[71]
3079 #define SWIGTYPE_p_p_unsigned_char swig_types[72]
3080 #define SWIGTYPE_p_short swig_types[73]
3081 #define SWIGTYPE_p_signed_char swig_types[74]
3082 #define SWIGTYPE_p_size_t swig_types[75]
3083 #define SWIGTYPE_p_ssize_t swig_types[76]
3084 #define SWIGTYPE_p_std__shared_ptrT_libbgp__BgpCapability_t swig_types[77]
3085 #define SWIGTYPE_p_std__vectorT_Prefix4_t swig_types[78]
3086 #define SWIGTYPE_p_std__vectorT_Prefix6_t swig_types[79]
3087 #define SWIGTYPE_p_std__vectorT_libbgp__BgpAsPathSegment_t swig_types[80]
3088 #define SWIGTYPE_p_std__vectorT_libbgp__BgpRib4Entry_t swig_types[81]
3089 #define SWIGTYPE_p_std__vectorT_libbgp__BgpRib6Entry_t swig_types[82]
3090 #define SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t swig_types[83]
3091 #define SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t swig_types[84]
3092 #define SWIGTYPE_p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t swig_types[85]
3093 #define SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpCapability_t_t swig_types[86]
3094 #define SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t swig_types[87]
3095 #define SWIGTYPE_p_std__vectorT_unsigned_int_t swig_types[88]
3096 #define SWIGTYPE_p_unsigned_char swig_types[89]
3097 #define SWIGTYPE_p_unsigned_int swig_types[90]
3098 #define SWIGTYPE_p_unsigned_long_long swig_types[91]
3099 #define SWIGTYPE_p_unsigned_short swig_types[92]
3100 static swig_type_info *swig_types[94];
3101 static swig_module_info swig_module = {swig_types, 93, 0, 0, 0, 0};
3102 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3103 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3104 
3105 /* -------- TYPES TABLE (END) -------- */
3106 
3107 #if (PY_VERSION_HEX <= 0x02000000)
3108 # if !defined(SWIG_PYTHON_CLASSIC)
3109 # error "This python version requires swig to be run with the '-classic' option"
3110 # endif
3111 #endif
3112 
3113 /*-----------------------------------------------
3114  @(target):= _libbgp.so
3115  ------------------------------------------------*/
3116 #if PY_VERSION_HEX >= 0x03000000
3117 # define SWIG_init PyInit__libbgp
3118 
3119 #else
3120 # define SWIG_init init_libbgp
3121 
3122 #endif
3123 #define SWIG_name "_libbgp"
3124 
3125 #define SWIGVERSION 0x030010
3126 #define SWIG_VERSION SWIGVERSION
3127 
3128 
3129 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
3130 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
3131 
3132 
3133 #include <stdexcept>
3134 
3135 
3136 namespace swig {
3138  protected:
3139  PyObject *_obj;
3140 
3141  public:
3142  SwigPtr_PyObject() :_obj(0)
3143  {
3144  }
3145 
3146  SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
3147  {
3148  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3149  Py_XINCREF(_obj);
3150  SWIG_PYTHON_THREAD_END_BLOCK;
3151  }
3152 
3153  SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
3154  {
3155  if (initial_ref) {
3156  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3157  Py_XINCREF(_obj);
3158  SWIG_PYTHON_THREAD_END_BLOCK;
3159  }
3160  }
3161 
3162  SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
3163  {
3164  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3165  Py_XINCREF(item._obj);
3166  Py_XDECREF(_obj);
3167  _obj = item._obj;
3168  SWIG_PYTHON_THREAD_END_BLOCK;
3169  return *this;
3170  }
3171 
3172  ~SwigPtr_PyObject()
3173  {
3174  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3175  Py_XDECREF(_obj);
3176  SWIG_PYTHON_THREAD_END_BLOCK;
3177  }
3178 
3179  operator PyObject *() const
3180  {
3181  return _obj;
3182  }
3183 
3184  PyObject *operator->() const
3185  {
3186  return _obj;
3187  }
3188  };
3189 }
3190 
3191 
3192 namespace swig {
3194  SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
3195 
3196  SwigVar_PyObject & operator = (PyObject* obj)
3197  {
3198  Py_XDECREF(_obj);
3199  _obj = obj;
3200  return *this;
3201  }
3202  };
3203 }
3204 
3205 
3206 #include "route-event-receiver.h"
3207 #include "fd-out-handler.h"
3208 #include "realtime-clock.h"
3209 #include "bgp-fsm.h"
3210 using namespace libbgp;
3211 
3212 
3213 #include <stdint.h> // Use the C99 official header
3214 
3215 
3216 SWIGINTERN int
3217 SWIG_AsVal_double (PyObject *obj, double *val)
3218 {
3219  int res = SWIG_TypeError;
3220  if (PyFloat_Check(obj)) {
3221  if (val) *val = PyFloat_AsDouble(obj);
3222  return SWIG_OK;
3223 #if PY_VERSION_HEX < 0x03000000
3224  } else if (PyInt_Check(obj)) {
3225  if (val) *val = PyInt_AsLong(obj);
3226  return SWIG_OK;
3227 #endif
3228  } else if (PyLong_Check(obj)) {
3229  double v = PyLong_AsDouble(obj);
3230  if (!PyErr_Occurred()) {
3231  if (val) *val = v;
3232  return SWIG_OK;
3233  } else {
3234  PyErr_Clear();
3235  }
3236  }
3237 #ifdef SWIG_PYTHON_CAST_MODE
3238  {
3239  int dispatch = 0;
3240  double d = PyFloat_AsDouble(obj);
3241  if (!PyErr_Occurred()) {
3242  if (val) *val = d;
3243  return SWIG_AddCast(SWIG_OK);
3244  } else {
3245  PyErr_Clear();
3246  }
3247  if (!dispatch) {
3248  long v = PyLong_AsLong(obj);
3249  if (!PyErr_Occurred()) {
3250  if (val) *val = v;
3251  return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3252  } else {
3253  PyErr_Clear();
3254  }
3255  }
3256  }
3257 #endif
3258  return res;
3259 }
3260 
3261 
3262 #include <float.h>
3263 
3264 
3265 #include <math.h>
3266 
3267 
3268 SWIGINTERNINLINE int
3269 SWIG_CanCastAsInteger(double *d, double min, double max) {
3270  double x = *d;
3271  if ((min <= x && x <= max)) {
3272  double fx = floor(x);
3273  double cx = ceil(x);
3274  double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3275  if ((errno == EDOM) || (errno == ERANGE)) {
3276  errno = 0;
3277  } else {
3278  double summ, reps, diff;
3279  if (rd < x) {
3280  diff = x - rd;
3281  } else if (rd > x) {
3282  diff = rd - x;
3283  } else {
3284  return 1;
3285  }
3286  summ = rd + x;
3287  reps = diff/summ;
3288  if (reps < 8*DBL_EPSILON) {
3289  *d = rd;
3290  return 1;
3291  }
3292  }
3293  }
3294  return 0;
3295 }
3296 
3297 
3298 SWIGINTERN int
3299 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3300 {
3301 #if PY_VERSION_HEX < 0x03000000
3302  if (PyInt_Check(obj)) {
3303  long v = PyInt_AsLong(obj);
3304  if (v >= 0) {
3305  if (val) *val = v;
3306  return SWIG_OK;
3307  } else {
3308  return SWIG_OverflowError;
3309  }
3310  } else
3311 #endif
3312  if (PyLong_Check(obj)) {
3313  unsigned long v = PyLong_AsUnsignedLong(obj);
3314  if (!PyErr_Occurred()) {
3315  if (val) *val = v;
3316  return SWIG_OK;
3317  } else {
3318  PyErr_Clear();
3319  return SWIG_OverflowError;
3320  }
3321  }
3322 #ifdef SWIG_PYTHON_CAST_MODE
3323  {
3324  int dispatch = 0;
3325  unsigned long v = PyLong_AsUnsignedLong(obj);
3326  if (!PyErr_Occurred()) {
3327  if (val) *val = v;
3328  return SWIG_AddCast(SWIG_OK);
3329  } else {
3330  PyErr_Clear();
3331  }
3332  if (!dispatch) {
3333  double d;
3334  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3335  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3336  if (val) *val = (unsigned long)(d);
3337  return res;
3338  }
3339  }
3340  }
3341 #endif
3342  return SWIG_TypeError;
3343 }
3344 
3345 
3346 #include <limits.h>
3347 #if !defined(SWIG_NO_LLONG_MAX)
3348 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3349 # define LLONG_MAX __LONG_LONG_MAX__
3350 # define LLONG_MIN (-LLONG_MAX - 1LL)
3351 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3352 # endif
3353 #endif
3354 
3355 
3356 #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
3357 # define SWIG_LONG_LONG_AVAILABLE
3358 #endif
3359 
3360 
3361 #ifdef SWIG_LONG_LONG_AVAILABLE
3362 SWIGINTERN int
3363 SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
3364 {
3365  int res = SWIG_TypeError;
3366  if (PyLong_Check(obj)) {
3367  unsigned long long v = PyLong_AsUnsignedLongLong(obj);
3368  if (!PyErr_Occurred()) {
3369  if (val) *val = v;
3370  return SWIG_OK;
3371  } else {
3372  PyErr_Clear();
3373  res = SWIG_OverflowError;
3374  }
3375  } else {
3376  unsigned long v;
3377  res = SWIG_AsVal_unsigned_SS_long (obj,&v);
3378  if (SWIG_IsOK(res)) {
3379  if (val) *val = v;
3380  return res;
3381  }
3382  }
3383 #ifdef SWIG_PYTHON_CAST_MODE
3384  {
3385  const double mant_max = 1LL << DBL_MANT_DIG;
3386  double d;
3387  res = SWIG_AsVal_double (obj,&d);
3388  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
3389  if (val) *val = (unsigned long long)(d);
3390  return SWIG_AddCast(res);
3391  }
3392  res = SWIG_TypeError;
3393  }
3394 #endif
3395  return res;
3396 }
3397 #endif
3398 
3399 
3400 SWIGINTERNINLINE int
3401 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3402 {
3403  int res = SWIG_TypeError;
3404 #ifdef SWIG_LONG_LONG_AVAILABLE
3405  if (sizeof(size_t) <= sizeof(unsigned long)) {
3406 #endif
3407  unsigned long v;
3408  res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3409  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3410 #ifdef SWIG_LONG_LONG_AVAILABLE
3411  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
3412  unsigned long long v;
3413  res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
3414  if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3415  }
3416 #endif
3417  return res;
3418 }
3419 
3420 
3421 SWIGINTERNINLINE PyObject*
3422  SWIG_From_bool (bool value)
3423 {
3424  return PyBool_FromLong(value ? 1 : 0);
3425 }
3426 
3427 
3428  #define SWIG_From_long PyInt_FromLong
3429 
3430 
3431 SWIGINTERNINLINE PyObject*
3432 SWIG_From_unsigned_SS_long (unsigned long value)
3433 {
3434  return (value > LONG_MAX) ?
3435  PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3436 }
3437 
3438 
3439 SWIGINTERNINLINE PyObject *
3440 SWIG_From_unsigned_SS_char (unsigned char value)
3441 {
3442  return SWIG_From_unsigned_SS_long (value);
3443 }
3444 
3445 
3446 #ifdef SWIG_LONG_LONG_AVAILABLE
3447 SWIGINTERNINLINE PyObject*
3448 SWIG_From_unsigned_SS_long_SS_long (unsigned long long value)
3449 {
3450  return (value > LONG_MAX) ?
3451  PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
3452 }
3453 #endif
3454 
3455 
3456 SWIGINTERNINLINE PyObject *
3457 SWIG_From_size_t (size_t value)
3458 {
3459 #ifdef SWIG_LONG_LONG_AVAILABLE
3460  if (sizeof(size_t) <= sizeof(unsigned long)) {
3461 #endif
3462  return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3463 #ifdef SWIG_LONG_LONG_AVAILABLE
3464  } else {
3465  /* assume sizeof(size_t) <= sizeof(unsigned long long) */
3466  return SWIG_From_unsigned_SS_long_SS_long (static_cast< unsigned long long >(value));
3467  }
3468 #endif
3469 }
3470 
3471 
3472 SWIGINTERNINLINE PyObject*
3473  SWIG_From_int (int value)
3474 {
3475  return PyInt_FromLong((long) value);
3476 }
3477 
3478 
3479 SWIGINTERN int
3480 SWIG_AsVal_long (PyObject *obj, long* val)
3481 {
3482 #if PY_VERSION_HEX < 0x03000000
3483  if (PyInt_Check(obj)) {
3484  if (val) *val = PyInt_AsLong(obj);
3485  return SWIG_OK;
3486  } else
3487 #endif
3488  if (PyLong_Check(obj)) {
3489  long v = PyLong_AsLong(obj);
3490  if (!PyErr_Occurred()) {
3491  if (val) *val = v;
3492  return SWIG_OK;
3493  } else {
3494  PyErr_Clear();
3495  return SWIG_OverflowError;
3496  }
3497  }
3498 #ifdef SWIG_PYTHON_CAST_MODE
3499  {
3500  int dispatch = 0;
3501  long v = PyInt_AsLong(obj);
3502  if (!PyErr_Occurred()) {
3503  if (val) *val = v;
3504  return SWIG_AddCast(SWIG_OK);
3505  } else {
3506  PyErr_Clear();
3507  }
3508  if (!dispatch) {
3509  double d;
3510  int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3511  if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3512  if (val) *val = (long)(d);
3513  return res;
3514  }
3515  }
3516  }
3517 #endif
3518  return SWIG_TypeError;
3519 }
3520 
3521 
3522 SWIGINTERN int
3523 SWIG_AsVal_int (PyObject * obj, int *val)
3524 {
3525  long v;
3526  int res = SWIG_AsVal_long (obj, &v);
3527  if (SWIG_IsOK(res)) {
3528  if ((v < INT_MIN || v > INT_MAX)) {
3529  return SWIG_OverflowError;
3530  } else {
3531  if (val) *val = static_cast< int >(v);
3532  }
3533  }
3534  return res;
3535 }
3536 
3537 
3538 SWIGINTERN int
3539 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3540 {
3541  unsigned long v;
3542  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3543  if (SWIG_IsOK(res)) {
3544  if ((v > UINT_MAX)) {
3545  return SWIG_OverflowError;
3546  } else {
3547  if (val) *val = static_cast< unsigned int >(v);
3548  }
3549  }
3550  return res;
3551 }
3552 
3553 
3554 SWIGINTERNINLINE PyObject*
3555  SWIG_From_unsigned_SS_int (unsigned int value)
3556 {
3557  return PyInt_FromSize_t((size_t) value);
3558 }
3559 
3560 
3561 SWIGINTERN int
3562 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3563 {
3564  unsigned long v;
3565  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3566  if (SWIG_IsOK(res)) {
3567  if ((v > UCHAR_MAX)) {
3568  return SWIG_OverflowError;
3569  } else {
3570  if (val) *val = static_cast< unsigned char >(v);
3571  }
3572  }
3573  return res;
3574 }
3575 
3576 
3577 SWIGINTERN swig_type_info*
3578 SWIG_pchar_descriptor(void)
3579 {
3580  static int init = 0;
3581  static swig_type_info* info = 0;
3582  if (!init) {
3583  info = SWIG_TypeQuery("_p_char");
3584  init = 1;
3585  }
3586  return info;
3587 }
3588 
3589 
3590 SWIGINTERN int
3591 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3592 {
3593 #if PY_VERSION_HEX>=0x03000000
3594 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3595  if (PyBytes_Check(obj))
3596 #else
3597  if (PyUnicode_Check(obj))
3598 #endif
3599 #else
3600  if (PyString_Check(obj))
3601 #endif
3602  {
3603  char *cstr; Py_ssize_t len;
3604 #if PY_VERSION_HEX>=0x03000000
3605 #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3606  if (!alloc && cptr) {
3607  /* We can't allow converting without allocation, since the internal
3608  representation of string in Python 3 is UCS-2/UCS-4 but we require
3609  a UTF-8 representation.
3610  TODO(bhy) More detailed explanation */
3611  return SWIG_RuntimeError;
3612  }
3613  obj = PyUnicode_AsUTF8String(obj);
3614  if(alloc) *alloc = SWIG_NEWOBJ;
3615 #endif
3616  PyBytes_AsStringAndSize(obj, &cstr, &len);
3617 #else
3618  PyString_AsStringAndSize(obj, &cstr, &len);
3619 #endif
3620  if (cptr) {
3621  if (alloc) {
3622  /*
3623  In python the user should not be able to modify the inner
3624  string representation. To warranty that, if you define
3625  SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3626  buffer is always returned.
3627 
3628  The default behavior is just to return the pointer value,
3629  so, be careful.
3630  */
3631 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3632  if (*alloc != SWIG_OLDOBJ)
3633 #else
3634  if (*alloc == SWIG_NEWOBJ)
3635 #endif
3636  {
3637  *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3638  *alloc = SWIG_NEWOBJ;
3639  } else {
3640  *cptr = cstr;
3641  *alloc = SWIG_OLDOBJ;
3642  }
3643  } else {
3644 #if PY_VERSION_HEX>=0x03000000
3645 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3646  *cptr = PyBytes_AsString(obj);
3647 #else
3648  assert(0); /* Should never reach here with Unicode strings in Python 3 */
3649 #endif
3650 #else
3651  *cptr = SWIG_Python_str_AsChar(obj);
3652 #endif
3653  }
3654  }
3655  if (psize) *psize = len + 1;
3656 #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3657  Py_XDECREF(obj);
3658 #endif
3659  return SWIG_OK;
3660  } else {
3661 #if defined(SWIG_PYTHON_2_UNICODE)
3662 #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3663 #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3664 #endif
3665 #if PY_VERSION_HEX<0x03000000
3666  if (PyUnicode_Check(obj)) {
3667  char *cstr; Py_ssize_t len;
3668  if (!alloc && cptr) {
3669  return SWIG_RuntimeError;
3670  }
3671  obj = PyUnicode_AsUTF8String(obj);
3672  if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3673  if (cptr) {
3674  if (alloc) *alloc = SWIG_NEWOBJ;
3675  *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3676  }
3677  if (psize) *psize = len + 1;
3678 
3679  Py_XDECREF(obj);
3680  return SWIG_OK;
3681  } else {
3682  Py_XDECREF(obj);
3683  }
3684  }
3685 #endif
3686 #endif
3687 
3688  swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3689  if (pchar_descriptor) {
3690  void* vptr = 0;
3691  if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3692  if (cptr) *cptr = (char *) vptr;
3693  if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3694  if (alloc) *alloc = SWIG_OLDOBJ;
3695  return SWIG_OK;
3696  }
3697  }
3698  }
3699  return SWIG_TypeError;
3700 }
3701 
3702 
3703 
3704 
3705 
3706 SWIGINTERN int
3707 SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val)
3708 {
3709  unsigned long v;
3710  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3711  if (SWIG_IsOK(res)) {
3712  if ((v > USHRT_MAX)) {
3713  return SWIG_OverflowError;
3714  } else {
3715  if (val) *val = static_cast< unsigned short >(v);
3716  }
3717  }
3718  return res;
3719 }
3720 
3721 
3722 SWIGINTERNINLINE PyObject *
3723 SWIG_From_unsigned_SS_short (unsigned short value)
3724 {
3725  return SWIG_From_unsigned_SS_long (value);
3726 }
3727 
3728 
3729 SWIGINTERN int
3730 SWIG_AsVal_bool (PyObject *obj, bool *val)
3731 {
3732  int r;
3733  if (!PyBool_Check(obj))
3734  return SWIG_ERROR;
3735  r = PyObject_IsTrue(obj);
3736  if (r == -1)
3737  return SWIG_ERROR;
3738  if (val) *val = r ? true : false;
3739  return SWIG_OK;
3740 }
3741 
3742 
3743 SWIGINTERN int
3744 SWIG_AsVal_signed_SS_char (PyObject * obj, signed char *val)
3745 {
3746  long v;
3747  int res = SWIG_AsVal_long (obj, &v);
3748  if (SWIG_IsOK(res)) {
3749  if ((v < SCHAR_MIN || v > SCHAR_MAX)) {
3750  return SWIG_OverflowError;
3751  } else {
3752  if (val) *val = static_cast< signed char >(v);
3753  }
3754  }
3755  return res;
3756 }
3757 
3758 
3759 SWIGINTERNINLINE PyObject *
3760 SWIG_From_signed_SS_char (signed char value)
3761 {
3762  return SWIG_From_long (value);
3763 }
3764 
3765 
3766 SWIGINTERNINLINE PyObject *
3767 SWIG_From_short (short value)
3768 {
3769  return SWIG_From_long (value);
3770 }
3771 
3772 #ifdef __cplusplus
3773 extern "C" {
3774 #endif
3775 SWIGINTERN PyObject *_wrap_delete_Serializable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3776  PyObject *resultobj = 0;
3778  void *argp1 = 0 ;
3779  int res1 = 0 ;
3780  PyObject * obj0 = 0 ;
3781 
3782  if (!PyArg_ParseTuple(args,(char *)"O:delete_Serializable",&obj0)) SWIG_fail;
3783  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Serializable, SWIG_POINTER_DISOWN | 0 );
3784  if (!SWIG_IsOK(res1)) {
3785  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Serializable" "', argument " "1"" of type '" "libbgp::Serializable *""'");
3786  }
3787  arg1 = reinterpret_cast< libbgp::Serializable * >(argp1);
3788  delete arg1;
3789  resultobj = SWIG_Py_Void();
3790  return resultobj;
3791 fail:
3792  return NULL;
3793 }
3794 
3795 
3796 SWIGINTERN PyObject *_wrap_Serializable__print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3797  PyObject *resultobj = 0;
3799  uint8_t *arg2 = (uint8_t *) 0 ;
3800  size_t arg3 ;
3801  void *argp1 = 0 ;
3802  int res1 = 0 ;
3803  void *argp2 = 0 ;
3804  int res2 = 0 ;
3805  size_t val3 ;
3806  int ecode3 = 0 ;
3807  PyObject * obj0 = 0 ;
3808  PyObject * obj1 = 0 ;
3809  PyObject * obj2 = 0 ;
3810  ssize_t result;
3811 
3812  if (!PyArg_ParseTuple(args,(char *)"OOO:Serializable__print",&obj0,&obj1,&obj2)) SWIG_fail;
3813  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Serializable, 0 | 0 );
3814  if (!SWIG_IsOK(res1)) {
3815  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Serializable__print" "', argument " "1"" of type '" "libbgp::Serializable const *""'");
3816  }
3817  arg1 = reinterpret_cast< libbgp::Serializable * >(argp1);
3818  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
3819  if (!SWIG_IsOK(res2)) {
3820  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Serializable__print" "', argument " "2"" of type '" "uint8_t *""'");
3821  }
3822  arg2 = reinterpret_cast< uint8_t * >(argp2);
3823  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
3824  if (!SWIG_IsOK(ecode3)) {
3825  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Serializable__print" "', argument " "3"" of type '" "size_t""'");
3826  }
3827  arg3 = static_cast< size_t >(val3);
3828  result = ((libbgp::Serializable const *)arg1)->print(arg2,arg3);
3829  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
3830  return resultobj;
3831 fail:
3832  return NULL;
3833 }
3834 
3835 
3836 SWIGINTERN PyObject *_wrap_Serializable__print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3837  PyObject *resultobj = 0;
3839  size_t arg2 ;
3840  uint8_t *arg3 = (uint8_t *) 0 ;
3841  size_t arg4 ;
3842  void *argp1 = 0 ;
3843  int res1 = 0 ;
3844  size_t val2 ;
3845  int ecode2 = 0 ;
3846  void *argp3 = 0 ;
3847  int res3 = 0 ;
3848  size_t val4 ;
3849  int ecode4 = 0 ;
3850  PyObject * obj0 = 0 ;
3851  PyObject * obj1 = 0 ;
3852  PyObject * obj2 = 0 ;
3853  PyObject * obj3 = 0 ;
3854  ssize_t result;
3855 
3856  if (!PyArg_ParseTuple(args,(char *)"OOOO:Serializable__print",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3857  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Serializable, 0 | 0 );
3858  if (!SWIG_IsOK(res1)) {
3859  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Serializable__print" "', argument " "1"" of type '" "libbgp::Serializable const *""'");
3860  }
3861  arg1 = reinterpret_cast< libbgp::Serializable * >(argp1);
3862  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
3863  if (!SWIG_IsOK(ecode2)) {
3864  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Serializable__print" "', argument " "2"" of type '" "size_t""'");
3865  }
3866  arg2 = static_cast< size_t >(val2);
3867  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 );
3868  if (!SWIG_IsOK(res3)) {
3869  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Serializable__print" "', argument " "3"" of type '" "uint8_t *""'");
3870  }
3871  arg3 = reinterpret_cast< uint8_t * >(argp3);
3872  ecode4 = SWIG_AsVal_size_t(obj3, &val4);
3873  if (!SWIG_IsOK(ecode4)) {
3874  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Serializable__print" "', argument " "4"" of type '" "size_t""'");
3875  }
3876  arg4 = static_cast< size_t >(val4);
3877  result = ((libbgp::Serializable const *)arg1)->print(arg2,arg3,arg4);
3878  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
3879  return resultobj;
3880 fail:
3881  return NULL;
3882 }
3883 
3884 
3885 SWIGINTERN PyObject *_wrap_Serializable__print(PyObject *self, PyObject *args) {
3886  Py_ssize_t argc;
3887  PyObject *argv[5] = {
3888  0
3889  };
3890  Py_ssize_t ii;
3891 
3892  if (!PyTuple_Check(args)) SWIG_fail;
3893  argc = args ? PyObject_Length(args) : 0;
3894  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
3895  argv[ii] = PyTuple_GET_ITEM(args,ii);
3896  }
3897  if (argc == 3) {
3898  int _v;
3899  void *vptr = 0;
3900  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__Serializable, 0);
3901  _v = SWIG_CheckState(res);
3902  if (_v) {
3903  void *vptr = 0;
3904  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
3905  _v = SWIG_CheckState(res);
3906  if (_v) {
3907  {
3908  int res = SWIG_AsVal_size_t(argv[2], NULL);
3909  _v = SWIG_CheckState(res);
3910  }
3911  if (_v) {
3912  return _wrap_Serializable__print__SWIG_0(self, args);
3913  }
3914  }
3915  }
3916  }
3917  if (argc == 4) {
3918  int _v;
3919  void *vptr = 0;
3920  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__Serializable, 0);
3921  _v = SWIG_CheckState(res);
3922  if (_v) {
3923  {
3924  int res = SWIG_AsVal_size_t(argv[1], NULL);
3925  _v = SWIG_CheckState(res);
3926  }
3927  if (_v) {
3928  void *vptr = 0;
3929  int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0);
3930  _v = SWIG_CheckState(res);
3931  if (_v) {
3932  {
3933  int res = SWIG_AsVal_size_t(argv[3], NULL);
3934  _v = SWIG_CheckState(res);
3935  }
3936  if (_v) {
3937  return _wrap_Serializable__print__SWIG_1(self, args);
3938  }
3939  }
3940  }
3941  }
3942  }
3943 
3944 fail:
3945  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Serializable__print'.\n"
3946  " Possible C/C++ prototypes are:\n"
3947  " libbgp::Serializable::print(uint8_t *,size_t) const\n"
3948  " libbgp::Serializable::print(size_t,uint8_t *,size_t) const\n");
3949  return 0;
3950 }
3951 
3952 
3953 SWIGINTERN PyObject *_wrap_Serializable_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3954  PyObject *resultobj = 0;
3956  uint8_t *arg2 = (uint8_t *) 0 ;
3957  size_t arg3 ;
3958  void *argp1 = 0 ;
3959  int res1 = 0 ;
3960  void *argp2 = 0 ;
3961  int res2 = 0 ;
3962  size_t val3 ;
3963  int ecode3 = 0 ;
3964  PyObject * obj0 = 0 ;
3965  PyObject * obj1 = 0 ;
3966  PyObject * obj2 = 0 ;
3967  ssize_t result;
3968 
3969  if (!PyArg_ParseTuple(args,(char *)"OOO:Serializable_parse",&obj0,&obj1,&obj2)) SWIG_fail;
3970  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Serializable, 0 | 0 );
3971  if (!SWIG_IsOK(res1)) {
3972  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Serializable_parse" "', argument " "1"" of type '" "libbgp::Serializable *""'");
3973  }
3974  arg1 = reinterpret_cast< libbgp::Serializable * >(argp1);
3975  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
3976  if (!SWIG_IsOK(res2)) {
3977  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Serializable_parse" "', argument " "2"" of type '" "uint8_t const *""'");
3978  }
3979  arg2 = reinterpret_cast< uint8_t * >(argp2);
3980  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
3981  if (!SWIG_IsOK(ecode3)) {
3982  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Serializable_parse" "', argument " "3"" of type '" "size_t""'");
3983  }
3984  arg3 = static_cast< size_t >(val3);
3985  result = (arg1)->parse((uint8_t const *)arg2,arg3);
3986  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
3987  return resultobj;
3988 fail:
3989  return NULL;
3990 }
3991 
3992 
3993 SWIGINTERN PyObject *_wrap_Serializable_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3994  PyObject *resultobj = 0;
3996  uint8_t *arg2 = (uint8_t *) 0 ;
3997  size_t arg3 ;
3998  void *argp1 = 0 ;
3999  int res1 = 0 ;
4000  void *argp2 = 0 ;
4001  int res2 = 0 ;
4002  size_t val3 ;
4003  int ecode3 = 0 ;
4004  PyObject * obj0 = 0 ;
4005  PyObject * obj1 = 0 ;
4006  PyObject * obj2 = 0 ;
4007  ssize_t result;
4008 
4009  if (!PyArg_ParseTuple(args,(char *)"OOO:Serializable_write",&obj0,&obj1,&obj2)) SWIG_fail;
4010  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Serializable, 0 | 0 );
4011  if (!SWIG_IsOK(res1)) {
4012  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Serializable_write" "', argument " "1"" of type '" "libbgp::Serializable const *""'");
4013  }
4014  arg1 = reinterpret_cast< libbgp::Serializable * >(argp1);
4015  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
4016  if (!SWIG_IsOK(res2)) {
4017  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Serializable_write" "', argument " "2"" of type '" "uint8_t *""'");
4018  }
4019  arg2 = reinterpret_cast< uint8_t * >(argp2);
4020  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
4021  if (!SWIG_IsOK(ecode3)) {
4022  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Serializable_write" "', argument " "3"" of type '" "size_t""'");
4023  }
4024  arg3 = static_cast< size_t >(val3);
4025  result = ((libbgp::Serializable const *)arg1)->write(arg2,arg3);
4026  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
4027  return resultobj;
4028 fail:
4029  return NULL;
4030 }
4031 
4032 
4033 SWIGINTERN PyObject *_wrap_Serializable_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4034  PyObject *resultobj = 0;
4036  void *argp1 = 0 ;
4037  int res1 = 0 ;
4038  PyObject * obj0 = 0 ;
4039  ssize_t result;
4040 
4041  if (!PyArg_ParseTuple(args,(char *)"O:Serializable_length",&obj0)) SWIG_fail;
4042  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Serializable, 0 | 0 );
4043  if (!SWIG_IsOK(res1)) {
4044  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Serializable_length" "', argument " "1"" of type '" "libbgp::Serializable const *""'");
4045  }
4046  arg1 = reinterpret_cast< libbgp::Serializable * >(argp1);
4047  result = ((libbgp::Serializable const *)arg1)->length();
4048  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
4049  return resultobj;
4050 fail:
4051  return NULL;
4052 }
4053 
4054 
4055 SWIGINTERN PyObject *_wrap_Serializable_hasError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4056  PyObject *resultobj = 0;
4058  void *argp1 = 0 ;
4059  int res1 = 0 ;
4060  PyObject * obj0 = 0 ;
4061  bool result;
4062 
4063  if (!PyArg_ParseTuple(args,(char *)"O:Serializable_hasError",&obj0)) SWIG_fail;
4064  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Serializable, 0 | 0 );
4065  if (!SWIG_IsOK(res1)) {
4066  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Serializable_hasError" "', argument " "1"" of type '" "libbgp::Serializable const *""'");
4067  }
4068  arg1 = reinterpret_cast< libbgp::Serializable * >(argp1);
4069  result = (bool)((libbgp::Serializable const *)arg1)->hasError();
4070  resultobj = SWIG_From_bool(static_cast< bool >(result));
4071  return resultobj;
4072 fail:
4073  return NULL;
4074 }
4075 
4076 
4077 SWIGINTERN PyObject *_wrap_Serializable_getErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4078  PyObject *resultobj = 0;
4080  void *argp1 = 0 ;
4081  int res1 = 0 ;
4082  PyObject * obj0 = 0 ;
4083  uint8_t result;
4084 
4085  if (!PyArg_ParseTuple(args,(char *)"O:Serializable_getErrorCode",&obj0)) SWIG_fail;
4086  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Serializable, 0 | 0 );
4087  if (!SWIG_IsOK(res1)) {
4088  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Serializable_getErrorCode" "', argument " "1"" of type '" "libbgp::Serializable const *""'");
4089  }
4090  arg1 = reinterpret_cast< libbgp::Serializable * >(argp1);
4091  result = (uint8_t)((libbgp::Serializable const *)arg1)->getErrorCode();
4092  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
4093  return resultobj;
4094 fail:
4095  return NULL;
4096 }
4097 
4098 
4099 SWIGINTERN PyObject *_wrap_Serializable_getErrorSubCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4100  PyObject *resultobj = 0;
4102  void *argp1 = 0 ;
4103  int res1 = 0 ;
4104  PyObject * obj0 = 0 ;
4105  uint8_t result;
4106 
4107  if (!PyArg_ParseTuple(args,(char *)"O:Serializable_getErrorSubCode",&obj0)) SWIG_fail;
4108  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Serializable, 0 | 0 );
4109  if (!SWIG_IsOK(res1)) {
4110  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Serializable_getErrorSubCode" "', argument " "1"" of type '" "libbgp::Serializable const *""'");
4111  }
4112  arg1 = reinterpret_cast< libbgp::Serializable * >(argp1);
4113  result = (uint8_t)((libbgp::Serializable const *)arg1)->getErrorSubCode();
4114  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
4115  return resultobj;
4116 fail:
4117  return NULL;
4118 }
4119 
4120 
4121 SWIGINTERN PyObject *_wrap_Serializable_getError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4122  PyObject *resultobj = 0;
4124  void *argp1 = 0 ;
4125  int res1 = 0 ;
4126  PyObject * obj0 = 0 ;
4127  uint8_t *result = 0 ;
4128 
4129  if (!PyArg_ParseTuple(args,(char *)"O:Serializable_getError",&obj0)) SWIG_fail;
4130  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Serializable, 0 | 0 );
4131  if (!SWIG_IsOK(res1)) {
4132  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Serializable_getError" "', argument " "1"" of type '" "libbgp::Serializable const *""'");
4133  }
4134  arg1 = reinterpret_cast< libbgp::Serializable * >(argp1);
4135  result = (uint8_t *)((libbgp::Serializable const *)arg1)->getError();
4136  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
4137  return resultobj;
4138 fail:
4139  return NULL;
4140 }
4141 
4142 
4143 SWIGINTERN PyObject *_wrap_Serializable_getErrorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4144  PyObject *resultobj = 0;
4146  void *argp1 = 0 ;
4147  int res1 = 0 ;
4148  PyObject * obj0 = 0 ;
4149  size_t result;
4150 
4151  if (!PyArg_ParseTuple(args,(char *)"O:Serializable_getErrorLength",&obj0)) SWIG_fail;
4152  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Serializable, 0 | 0 );
4153  if (!SWIG_IsOK(res1)) {
4154  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Serializable_getErrorLength" "', argument " "1"" of type '" "libbgp::Serializable const *""'");
4155  }
4156  arg1 = reinterpret_cast< libbgp::Serializable * >(argp1);
4157  result = ((libbgp::Serializable const *)arg1)->getErrorLength();
4158  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
4159  return resultobj;
4160 fail:
4161  return NULL;
4162 }
4163 
4164 
4165 SWIGINTERN PyObject *_wrap_Serializable_setLogger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4166  PyObject *resultobj = 0;
4169  void *argp1 = 0 ;
4170  int res1 = 0 ;
4171  void *argp2 = 0 ;
4172  int res2 = 0 ;
4173  PyObject * obj0 = 0 ;
4174  PyObject * obj1 = 0 ;
4175 
4176  if (!PyArg_ParseTuple(args,(char *)"OO:Serializable_setLogger",&obj0,&obj1)) SWIG_fail;
4177  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Serializable, 0 | 0 );
4178  if (!SWIG_IsOK(res1)) {
4179  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Serializable_setLogger" "', argument " "1"" of type '" "libbgp::Serializable *""'");
4180  }
4181  arg1 = reinterpret_cast< libbgp::Serializable * >(argp1);
4182  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
4183  if (!SWIG_IsOK(res2)) {
4184  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Serializable_setLogger" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
4185  }
4186  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
4187  (arg1)->setLogger(arg2);
4188  resultobj = SWIG_Py_Void();
4189  return resultobj;
4190 fail:
4191  return NULL;
4192 }
4193 
4194 
4195 SWIGINTERN PyObject *Serializable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4196  PyObject *obj;
4197  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4198  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__Serializable, SWIG_NewClientData(obj));
4199  return SWIG_Py_Void();
4200 }
4201 
4202 SWIGINTERN PyObject *_wrap_RouteEvent_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4203  PyObject *resultobj = 0;
4204  libbgp::RouteEvent *arg1 = (libbgp::RouteEvent *) 0 ;
4205  libbgp::RouteEventType arg2 ;
4206  void *argp1 = 0 ;
4207  int res1 = 0 ;
4208  int val2 ;
4209  int ecode2 = 0 ;
4210  PyObject * obj0 = 0 ;
4211  PyObject * obj1 = 0 ;
4212 
4213  if (!PyArg_ParseTuple(args,(char *)"OO:RouteEvent_type_set",&obj0,&obj1)) SWIG_fail;
4214  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__RouteEvent, 0 | 0 );
4215  if (!SWIG_IsOK(res1)) {
4216  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RouteEvent_type_set" "', argument " "1"" of type '" "libbgp::RouteEvent *""'");
4217  }
4218  arg1 = reinterpret_cast< libbgp::RouteEvent * >(argp1);
4219  ecode2 = SWIG_AsVal_int(obj1, &val2);
4220  if (!SWIG_IsOK(ecode2)) {
4221  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RouteEvent_type_set" "', argument " "2"" of type '" "libbgp::RouteEventType""'");
4222  }
4223  arg2 = static_cast< libbgp::RouteEventType >(val2);
4224  if (arg1) (arg1)->type = arg2;
4225  resultobj = SWIG_Py_Void();
4226  return resultobj;
4227 fail:
4228  return NULL;
4229 }
4230 
4231 
4232 SWIGINTERN PyObject *_wrap_RouteEvent_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4233  PyObject *resultobj = 0;
4234  libbgp::RouteEvent *arg1 = (libbgp::RouteEvent *) 0 ;
4235  void *argp1 = 0 ;
4236  int res1 = 0 ;
4237  PyObject * obj0 = 0 ;
4238  libbgp::RouteEventType result;
4239 
4240  if (!PyArg_ParseTuple(args,(char *)"O:RouteEvent_type_get",&obj0)) SWIG_fail;
4241  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__RouteEvent, 0 | 0 );
4242  if (!SWIG_IsOK(res1)) {
4243  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RouteEvent_type_get" "', argument " "1"" of type '" "libbgp::RouteEvent *""'");
4244  }
4245  arg1 = reinterpret_cast< libbgp::RouteEvent * >(argp1);
4246  result = (libbgp::RouteEventType) ((arg1)->type);
4247  resultobj = SWIG_From_int(static_cast< int >(result));
4248  return resultobj;
4249 fail:
4250  return NULL;
4251 }
4252 
4253 
4254 SWIGINTERN PyObject *_wrap_delete_RouteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4255  PyObject *resultobj = 0;
4256  libbgp::RouteEvent *arg1 = (libbgp::RouteEvent *) 0 ;
4257  void *argp1 = 0 ;
4258  int res1 = 0 ;
4259  PyObject * obj0 = 0 ;
4260 
4261  if (!PyArg_ParseTuple(args,(char *)"O:delete_RouteEvent",&obj0)) SWIG_fail;
4262  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__RouteEvent, SWIG_POINTER_DISOWN | 0 );
4263  if (!SWIG_IsOK(res1)) {
4264  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RouteEvent" "', argument " "1"" of type '" "libbgp::RouteEvent *""'");
4265  }
4266  arg1 = reinterpret_cast< libbgp::RouteEvent * >(argp1);
4267  delete arg1;
4268  resultobj = SWIG_Py_Void();
4269  return resultobj;
4270 fail:
4271  return NULL;
4272 }
4273 
4274 
4275 SWIGINTERN PyObject *_wrap_new_RouteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4276  PyObject *resultobj = 0;
4277  libbgp::RouteEvent *result = 0 ;
4278 
4279  if (!PyArg_ParseTuple(args,(char *)":new_RouteEvent")) SWIG_fail;
4280  result = (libbgp::RouteEvent *)new libbgp::RouteEvent();
4281  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__RouteEvent, SWIG_POINTER_NEW | 0 );
4282  return resultobj;
4283 fail:
4284  return NULL;
4285 }
4286 
4287 
4288 SWIGINTERN PyObject *RouteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4289  PyObject *obj;
4290  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4291  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__RouteEvent, SWIG_NewClientData(obj));
4292  return SWIG_Py_Void();
4293 }
4294 
4295 SWIGINTERN PyObject *_wrap_new_Route4AddEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4296  PyObject *resultobj = 0;
4297  libbgp::Route4AddEvent *result = 0 ;
4298 
4299  if (!PyArg_ParseTuple(args,(char *)":new_Route4AddEvent")) SWIG_fail;
4301  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Route4AddEvent, SWIG_POINTER_NEW | 0 );
4302  return resultobj;
4303 fail:
4304  return NULL;
4305 }
4306 
4307 
4308 SWIGINTERN PyObject *_wrap_Route4AddEvent_attribs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4309  PyObject *resultobj = 0;
4311  std::vector< std::shared_ptr< BgpPathAttrib > > arg2 ;
4312  void *argp1 = 0 ;
4313  int res1 = 0 ;
4314  void *argp2 ;
4315  int res2 = 0 ;
4316  PyObject * obj0 = 0 ;
4317  PyObject * obj1 = 0 ;
4318 
4319  if (!PyArg_ParseTuple(args,(char *)"OO:Route4AddEvent_attribs_set",&obj0,&obj1)) SWIG_fail;
4320  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route4AddEvent, 0 | 0 );
4321  if (!SWIG_IsOK(res1)) {
4322  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Route4AddEvent_attribs_set" "', argument " "1"" of type '" "libbgp::Route4AddEvent *""'");
4323  }
4324  arg1 = reinterpret_cast< libbgp::Route4AddEvent * >(argp1);
4325  {
4326  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t, 0 | 0);
4327  if (!SWIG_IsOK(res2)) {
4328  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Route4AddEvent_attribs_set" "', argument " "2"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > >""'");
4329  }
4330  if (!argp2) {
4331  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Route4AddEvent_attribs_set" "', argument " "2"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > >""'");
4332  } else {
4333  std::vector< std::shared_ptr< BgpPathAttrib > > * temp = reinterpret_cast< std::vector< std::shared_ptr< BgpPathAttrib > > * >(argp2);
4334  arg2 = *temp;
4335  if (SWIG_IsNewObj(res2)) delete temp;
4336  }
4337  }
4338  if (arg1) (arg1)->attribs = arg2;
4339  resultobj = SWIG_Py_Void();
4340  return resultobj;
4341 fail:
4342  return NULL;
4343 }
4344 
4345 
4346 SWIGINTERN PyObject *_wrap_Route4AddEvent_attribs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4347  PyObject *resultobj = 0;
4349  void *argp1 = 0 ;
4350  int res1 = 0 ;
4351  PyObject * obj0 = 0 ;
4352  std::vector< std::shared_ptr< BgpPathAttrib > > result;
4353 
4354  if (!PyArg_ParseTuple(args,(char *)"O:Route4AddEvent_attribs_get",&obj0)) SWIG_fail;
4355  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route4AddEvent, 0 | 0 );
4356  if (!SWIG_IsOK(res1)) {
4357  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Route4AddEvent_attribs_get" "', argument " "1"" of type '" "libbgp::Route4AddEvent *""'");
4358  }
4359  arg1 = reinterpret_cast< libbgp::Route4AddEvent * >(argp1);
4360  result = ((arg1)->attribs);
4361  resultobj = SWIG_NewPointerObj((new std::vector< std::shared_ptr< BgpPathAttrib > >(static_cast< const std::vector< std::shared_ptr< BgpPathAttrib > >& >(result))), SWIGTYPE_p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t, SWIG_POINTER_OWN | 0 );
4362  return resultobj;
4363 fail:
4364  return NULL;
4365 }
4366 
4367 
4368 SWIGINTERN PyObject *_wrap_Route4AddEvent_routes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4369  PyObject *resultobj = 0;
4371  std::vector< Prefix4 > arg2 ;
4372  void *argp1 = 0 ;
4373  int res1 = 0 ;
4374  void *argp2 ;
4375  int res2 = 0 ;
4376  PyObject * obj0 = 0 ;
4377  PyObject * obj1 = 0 ;
4378 
4379  if (!PyArg_ParseTuple(args,(char *)"OO:Route4AddEvent_routes_set",&obj0,&obj1)) SWIG_fail;
4380  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route4AddEvent, 0 | 0 );
4381  if (!SWIG_IsOK(res1)) {
4382  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Route4AddEvent_routes_set" "', argument " "1"" of type '" "libbgp::Route4AddEvent *""'");
4383  }
4384  arg1 = reinterpret_cast< libbgp::Route4AddEvent * >(argp1);
4385  {
4386  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Prefix4_t, 0 | 0);
4387  if (!SWIG_IsOK(res2)) {
4388  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Route4AddEvent_routes_set" "', argument " "2"" of type '" "std::vector< Prefix4 >""'");
4389  }
4390  if (!argp2) {
4391  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Route4AddEvent_routes_set" "', argument " "2"" of type '" "std::vector< Prefix4 >""'");
4392  } else {
4393  std::vector< Prefix4 > * temp = reinterpret_cast< std::vector< Prefix4 > * >(argp2);
4394  arg2 = *temp;
4395  if (SWIG_IsNewObj(res2)) delete temp;
4396  }
4397  }
4398  if (arg1) (arg1)->routes = arg2;
4399  resultobj = SWIG_Py_Void();
4400  return resultobj;
4401 fail:
4402  return NULL;
4403 }
4404 
4405 
4406 SWIGINTERN PyObject *_wrap_Route4AddEvent_routes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4407  PyObject *resultobj = 0;
4409  void *argp1 = 0 ;
4410  int res1 = 0 ;
4411  PyObject * obj0 = 0 ;
4412  std::vector< Prefix4 > result;
4413 
4414  if (!PyArg_ParseTuple(args,(char *)"O:Route4AddEvent_routes_get",&obj0)) SWIG_fail;
4415  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route4AddEvent, 0 | 0 );
4416  if (!SWIG_IsOK(res1)) {
4417  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Route4AddEvent_routes_get" "', argument " "1"" of type '" "libbgp::Route4AddEvent *""'");
4418  }
4419  arg1 = reinterpret_cast< libbgp::Route4AddEvent * >(argp1);
4420  result = ((arg1)->routes);
4421  resultobj = SWIG_NewPointerObj((new std::vector< Prefix4 >(static_cast< const std::vector< Prefix4 >& >(result))), SWIGTYPE_p_std__vectorT_Prefix4_t, SWIG_POINTER_OWN | 0 );
4422  return resultobj;
4423 fail:
4424  return NULL;
4425 }
4426 
4427 
4428 SWIGINTERN PyObject *_wrap_delete_Route4AddEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4429  PyObject *resultobj = 0;
4431  void *argp1 = 0 ;
4432  int res1 = 0 ;
4433  PyObject * obj0 = 0 ;
4434 
4435  if (!PyArg_ParseTuple(args,(char *)"O:delete_Route4AddEvent",&obj0)) SWIG_fail;
4436  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route4AddEvent, SWIG_POINTER_DISOWN | 0 );
4437  if (!SWIG_IsOK(res1)) {
4438  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Route4AddEvent" "', argument " "1"" of type '" "libbgp::Route4AddEvent *""'");
4439  }
4440  arg1 = reinterpret_cast< libbgp::Route4AddEvent * >(argp1);
4441  delete arg1;
4442  resultobj = SWIG_Py_Void();
4443  return resultobj;
4444 fail:
4445  return NULL;
4446 }
4447 
4448 
4449 SWIGINTERN PyObject *Route4AddEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4450  PyObject *obj;
4451  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4452  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__Route4AddEvent, SWIG_NewClientData(obj));
4453  return SWIG_Py_Void();
4454 }
4455 
4456 SWIGINTERN PyObject *_wrap_new_Route4WithdrawEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4457  PyObject *resultobj = 0;
4458  libbgp::Route4WithdrawEvent *result = 0 ;
4459 
4460  if (!PyArg_ParseTuple(args,(char *)":new_Route4WithdrawEvent")) SWIG_fail;
4462  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Route4WithdrawEvent, SWIG_POINTER_NEW | 0 );
4463  return resultobj;
4464 fail:
4465  return NULL;
4466 }
4467 
4468 
4469 SWIGINTERN PyObject *_wrap_Route4WithdrawEvent_routes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4470  PyObject *resultobj = 0;
4472  std::vector< Prefix4 > arg2 ;
4473  void *argp1 = 0 ;
4474  int res1 = 0 ;
4475  void *argp2 ;
4476  int res2 = 0 ;
4477  PyObject * obj0 = 0 ;
4478  PyObject * obj1 = 0 ;
4479 
4480  if (!PyArg_ParseTuple(args,(char *)"OO:Route4WithdrawEvent_routes_set",&obj0,&obj1)) SWIG_fail;
4481  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route4WithdrawEvent, 0 | 0 );
4482  if (!SWIG_IsOK(res1)) {
4483  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Route4WithdrawEvent_routes_set" "', argument " "1"" of type '" "libbgp::Route4WithdrawEvent *""'");
4484  }
4485  arg1 = reinterpret_cast< libbgp::Route4WithdrawEvent * >(argp1);
4486  {
4487  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Prefix4_t, 0 | 0);
4488  if (!SWIG_IsOK(res2)) {
4489  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Route4WithdrawEvent_routes_set" "', argument " "2"" of type '" "std::vector< Prefix4 >""'");
4490  }
4491  if (!argp2) {
4492  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Route4WithdrawEvent_routes_set" "', argument " "2"" of type '" "std::vector< Prefix4 >""'");
4493  } else {
4494  std::vector< Prefix4 > * temp = reinterpret_cast< std::vector< Prefix4 > * >(argp2);
4495  arg2 = *temp;
4496  if (SWIG_IsNewObj(res2)) delete temp;
4497  }
4498  }
4499  if (arg1) (arg1)->routes = arg2;
4500  resultobj = SWIG_Py_Void();
4501  return resultobj;
4502 fail:
4503  return NULL;
4504 }
4505 
4506 
4507 SWIGINTERN PyObject *_wrap_Route4WithdrawEvent_routes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4508  PyObject *resultobj = 0;
4510  void *argp1 = 0 ;
4511  int res1 = 0 ;
4512  PyObject * obj0 = 0 ;
4513  std::vector< Prefix4 > result;
4514 
4515  if (!PyArg_ParseTuple(args,(char *)"O:Route4WithdrawEvent_routes_get",&obj0)) SWIG_fail;
4516  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route4WithdrawEvent, 0 | 0 );
4517  if (!SWIG_IsOK(res1)) {
4518  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Route4WithdrawEvent_routes_get" "', argument " "1"" of type '" "libbgp::Route4WithdrawEvent *""'");
4519  }
4520  arg1 = reinterpret_cast< libbgp::Route4WithdrawEvent * >(argp1);
4521  result = ((arg1)->routes);
4522  resultobj = SWIG_NewPointerObj((new std::vector< Prefix4 >(static_cast< const std::vector< Prefix4 >& >(result))), SWIGTYPE_p_std__vectorT_Prefix4_t, SWIG_POINTER_OWN | 0 );
4523  return resultobj;
4524 fail:
4525  return NULL;
4526 }
4527 
4528 
4529 SWIGINTERN PyObject *_wrap_delete_Route4WithdrawEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4530  PyObject *resultobj = 0;
4532  void *argp1 = 0 ;
4533  int res1 = 0 ;
4534  PyObject * obj0 = 0 ;
4535 
4536  if (!PyArg_ParseTuple(args,(char *)"O:delete_Route4WithdrawEvent",&obj0)) SWIG_fail;
4537  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route4WithdrawEvent, SWIG_POINTER_DISOWN | 0 );
4538  if (!SWIG_IsOK(res1)) {
4539  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Route4WithdrawEvent" "', argument " "1"" of type '" "libbgp::Route4WithdrawEvent *""'");
4540  }
4541  arg1 = reinterpret_cast< libbgp::Route4WithdrawEvent * >(argp1);
4542  delete arg1;
4543  resultobj = SWIG_Py_Void();
4544  return resultobj;
4545 fail:
4546  return NULL;
4547 }
4548 
4549 
4550 SWIGINTERN PyObject *Route4WithdrawEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4551  PyObject *obj;
4552  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4553  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__Route4WithdrawEvent, SWIG_NewClientData(obj));
4554  return SWIG_Py_Void();
4555 }
4556 
4557 SWIGINTERN PyObject *_wrap_new_Route6AddEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4558  PyObject *resultobj = 0;
4559  libbgp::Route6AddEvent *result = 0 ;
4560 
4561  if (!PyArg_ParseTuple(args,(char *)":new_Route6AddEvent")) SWIG_fail;
4563  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Route6AddEvent, SWIG_POINTER_NEW | 0 );
4564  return resultobj;
4565 fail:
4566  return NULL;
4567 }
4568 
4569 
4570 SWIGINTERN PyObject *_wrap_Route6AddEvent_attribs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4571  PyObject *resultobj = 0;
4573  std::vector< std::shared_ptr< BgpPathAttrib > > arg2 ;
4574  void *argp1 = 0 ;
4575  int res1 = 0 ;
4576  void *argp2 ;
4577  int res2 = 0 ;
4578  PyObject * obj0 = 0 ;
4579  PyObject * obj1 = 0 ;
4580 
4581  if (!PyArg_ParseTuple(args,(char *)"OO:Route6AddEvent_attribs_set",&obj0,&obj1)) SWIG_fail;
4582  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route6AddEvent, 0 | 0 );
4583  if (!SWIG_IsOK(res1)) {
4584  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Route6AddEvent_attribs_set" "', argument " "1"" of type '" "libbgp::Route6AddEvent *""'");
4585  }
4586  arg1 = reinterpret_cast< libbgp::Route6AddEvent * >(argp1);
4587  {
4588  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t, 0 | 0);
4589  if (!SWIG_IsOK(res2)) {
4590  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Route6AddEvent_attribs_set" "', argument " "2"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > >""'");
4591  }
4592  if (!argp2) {
4593  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Route6AddEvent_attribs_set" "', argument " "2"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > >""'");
4594  } else {
4595  std::vector< std::shared_ptr< BgpPathAttrib > > * temp = reinterpret_cast< std::vector< std::shared_ptr< BgpPathAttrib > > * >(argp2);
4596  arg2 = *temp;
4597  if (SWIG_IsNewObj(res2)) delete temp;
4598  }
4599  }
4600  if (arg1) (arg1)->attribs = arg2;
4601  resultobj = SWIG_Py_Void();
4602  return resultobj;
4603 fail:
4604  return NULL;
4605 }
4606 
4607 
4608 SWIGINTERN PyObject *_wrap_Route6AddEvent_attribs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4609  PyObject *resultobj = 0;
4611  void *argp1 = 0 ;
4612  int res1 = 0 ;
4613  PyObject * obj0 = 0 ;
4614  std::vector< std::shared_ptr< BgpPathAttrib > > result;
4615 
4616  if (!PyArg_ParseTuple(args,(char *)"O:Route6AddEvent_attribs_get",&obj0)) SWIG_fail;
4617  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route6AddEvent, 0 | 0 );
4618  if (!SWIG_IsOK(res1)) {
4619  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Route6AddEvent_attribs_get" "', argument " "1"" of type '" "libbgp::Route6AddEvent *""'");
4620  }
4621  arg1 = reinterpret_cast< libbgp::Route6AddEvent * >(argp1);
4622  result = ((arg1)->attribs);
4623  resultobj = SWIG_NewPointerObj((new std::vector< std::shared_ptr< BgpPathAttrib > >(static_cast< const std::vector< std::shared_ptr< BgpPathAttrib > >& >(result))), SWIGTYPE_p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t, SWIG_POINTER_OWN | 0 );
4624  return resultobj;
4625 fail:
4626  return NULL;
4627 }
4628 
4629 
4630 SWIGINTERN PyObject *_wrap_Route6AddEvent_routes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4631  PyObject *resultobj = 0;
4633  std::vector< Prefix6 > arg2 ;
4634  void *argp1 = 0 ;
4635  int res1 = 0 ;
4636  void *argp2 ;
4637  int res2 = 0 ;
4638  PyObject * obj0 = 0 ;
4639  PyObject * obj1 = 0 ;
4640 
4641  if (!PyArg_ParseTuple(args,(char *)"OO:Route6AddEvent_routes_set",&obj0,&obj1)) SWIG_fail;
4642  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route6AddEvent, 0 | 0 );
4643  if (!SWIG_IsOK(res1)) {
4644  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Route6AddEvent_routes_set" "', argument " "1"" of type '" "libbgp::Route6AddEvent *""'");
4645  }
4646  arg1 = reinterpret_cast< libbgp::Route6AddEvent * >(argp1);
4647  {
4648  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Prefix6_t, 0 | 0);
4649  if (!SWIG_IsOK(res2)) {
4650  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Route6AddEvent_routes_set" "', argument " "2"" of type '" "std::vector< Prefix6 >""'");
4651  }
4652  if (!argp2) {
4653  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Route6AddEvent_routes_set" "', argument " "2"" of type '" "std::vector< Prefix6 >""'");
4654  } else {
4655  std::vector< Prefix6 > * temp = reinterpret_cast< std::vector< Prefix6 > * >(argp2);
4656  arg2 = *temp;
4657  if (SWIG_IsNewObj(res2)) delete temp;
4658  }
4659  }
4660  if (arg1) (arg1)->routes = arg2;
4661  resultobj = SWIG_Py_Void();
4662  return resultobj;
4663 fail:
4664  return NULL;
4665 }
4666 
4667 
4668 SWIGINTERN PyObject *_wrap_Route6AddEvent_routes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4669  PyObject *resultobj = 0;
4671  void *argp1 = 0 ;
4672  int res1 = 0 ;
4673  PyObject * obj0 = 0 ;
4674  std::vector< Prefix6 > result;
4675 
4676  if (!PyArg_ParseTuple(args,(char *)"O:Route6AddEvent_routes_get",&obj0)) SWIG_fail;
4677  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route6AddEvent, 0 | 0 );
4678  if (!SWIG_IsOK(res1)) {
4679  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Route6AddEvent_routes_get" "', argument " "1"" of type '" "libbgp::Route6AddEvent *""'");
4680  }
4681  arg1 = reinterpret_cast< libbgp::Route6AddEvent * >(argp1);
4682  result = ((arg1)->routes);
4683  resultobj = SWIG_NewPointerObj((new std::vector< Prefix6 >(static_cast< const std::vector< Prefix6 >& >(result))), SWIGTYPE_p_std__vectorT_Prefix6_t, SWIG_POINTER_OWN | 0 );
4684  return resultobj;
4685 fail:
4686  return NULL;
4687 }
4688 
4689 
4690 SWIGINTERN PyObject *_wrap_delete_Route6AddEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4691  PyObject *resultobj = 0;
4693  void *argp1 = 0 ;
4694  int res1 = 0 ;
4695  PyObject * obj0 = 0 ;
4696 
4697  if (!PyArg_ParseTuple(args,(char *)"O:delete_Route6AddEvent",&obj0)) SWIG_fail;
4698  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route6AddEvent, SWIG_POINTER_DISOWN | 0 );
4699  if (!SWIG_IsOK(res1)) {
4700  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Route6AddEvent" "', argument " "1"" of type '" "libbgp::Route6AddEvent *""'");
4701  }
4702  arg1 = reinterpret_cast< libbgp::Route6AddEvent * >(argp1);
4703  delete arg1;
4704  resultobj = SWIG_Py_Void();
4705  return resultobj;
4706 fail:
4707  return NULL;
4708 }
4709 
4710 
4711 SWIGINTERN PyObject *Route6AddEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4712  PyObject *obj;
4713  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4714  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__Route6AddEvent, SWIG_NewClientData(obj));
4715  return SWIG_Py_Void();
4716 }
4717 
4718 SWIGINTERN PyObject *_wrap_new_Route6WithdrawEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4719  PyObject *resultobj = 0;
4720  libbgp::Route6WithdrawEvent *result = 0 ;
4721 
4722  if (!PyArg_ParseTuple(args,(char *)":new_Route6WithdrawEvent")) SWIG_fail;
4724  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Route6WithdrawEvent, SWIG_POINTER_NEW | 0 );
4725  return resultobj;
4726 fail:
4727  return NULL;
4728 }
4729 
4730 
4731 SWIGINTERN PyObject *_wrap_Route6WithdrawEvent_routes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4732  PyObject *resultobj = 0;
4734  std::vector< Prefix6 > arg2 ;
4735  void *argp1 = 0 ;
4736  int res1 = 0 ;
4737  void *argp2 ;
4738  int res2 = 0 ;
4739  PyObject * obj0 = 0 ;
4740  PyObject * obj1 = 0 ;
4741 
4742  if (!PyArg_ParseTuple(args,(char *)"OO:Route6WithdrawEvent_routes_set",&obj0,&obj1)) SWIG_fail;
4743  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route6WithdrawEvent, 0 | 0 );
4744  if (!SWIG_IsOK(res1)) {
4745  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Route6WithdrawEvent_routes_set" "', argument " "1"" of type '" "libbgp::Route6WithdrawEvent *""'");
4746  }
4747  arg1 = reinterpret_cast< libbgp::Route6WithdrawEvent * >(argp1);
4748  {
4749  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_Prefix6_t, 0 | 0);
4750  if (!SWIG_IsOK(res2)) {
4751  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Route6WithdrawEvent_routes_set" "', argument " "2"" of type '" "std::vector< Prefix6 >""'");
4752  }
4753  if (!argp2) {
4754  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Route6WithdrawEvent_routes_set" "', argument " "2"" of type '" "std::vector< Prefix6 >""'");
4755  } else {
4756  std::vector< Prefix6 > * temp = reinterpret_cast< std::vector< Prefix6 > * >(argp2);
4757  arg2 = *temp;
4758  if (SWIG_IsNewObj(res2)) delete temp;
4759  }
4760  }
4761  if (arg1) (arg1)->routes = arg2;
4762  resultobj = SWIG_Py_Void();
4763  return resultobj;
4764 fail:
4765  return NULL;
4766 }
4767 
4768 
4769 SWIGINTERN PyObject *_wrap_Route6WithdrawEvent_routes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4770  PyObject *resultobj = 0;
4772  void *argp1 = 0 ;
4773  int res1 = 0 ;
4774  PyObject * obj0 = 0 ;
4775  std::vector< Prefix6 > result;
4776 
4777  if (!PyArg_ParseTuple(args,(char *)"O:Route6WithdrawEvent_routes_get",&obj0)) SWIG_fail;
4778  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route6WithdrawEvent, 0 | 0 );
4779  if (!SWIG_IsOK(res1)) {
4780  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Route6WithdrawEvent_routes_get" "', argument " "1"" of type '" "libbgp::Route6WithdrawEvent *""'");
4781  }
4782  arg1 = reinterpret_cast< libbgp::Route6WithdrawEvent * >(argp1);
4783  result = ((arg1)->routes);
4784  resultobj = SWIG_NewPointerObj((new std::vector< Prefix6 >(static_cast< const std::vector< Prefix6 >& >(result))), SWIGTYPE_p_std__vectorT_Prefix6_t, SWIG_POINTER_OWN | 0 );
4785  return resultobj;
4786 fail:
4787  return NULL;
4788 }
4789 
4790 
4791 SWIGINTERN PyObject *_wrap_delete_Route6WithdrawEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4792  PyObject *resultobj = 0;
4794  void *argp1 = 0 ;
4795  int res1 = 0 ;
4796  PyObject * obj0 = 0 ;
4797 
4798  if (!PyArg_ParseTuple(args,(char *)"O:delete_Route6WithdrawEvent",&obj0)) SWIG_fail;
4799  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Route6WithdrawEvent, SWIG_POINTER_DISOWN | 0 );
4800  if (!SWIG_IsOK(res1)) {
4801  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Route6WithdrawEvent" "', argument " "1"" of type '" "libbgp::Route6WithdrawEvent *""'");
4802  }
4803  arg1 = reinterpret_cast< libbgp::Route6WithdrawEvent * >(argp1);
4804  delete arg1;
4805  resultobj = SWIG_Py_Void();
4806  return resultobj;
4807 fail:
4808  return NULL;
4809 }
4810 
4811 
4812 SWIGINTERN PyObject *Route6WithdrawEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4813  PyObject *obj;
4814  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4815  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__Route6WithdrawEvent, SWIG_NewClientData(obj));
4816  return SWIG_Py_Void();
4817 }
4818 
4819 SWIGINTERN PyObject *_wrap_new_RouteCollisionEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4820  PyObject *resultobj = 0;
4821  libbgp::RouteCollisionEvent *result = 0 ;
4822 
4823  if (!PyArg_ParseTuple(args,(char *)":new_RouteCollisionEvent")) SWIG_fail;
4825  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__RouteCollisionEvent, SWIG_POINTER_NEW | 0 );
4826  return resultobj;
4827 fail:
4828  return NULL;
4829 }
4830 
4831 
4832 SWIGINTERN PyObject *_wrap_RouteCollisionEvent_peer_bgp_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4833  PyObject *resultobj = 0;
4835  uint32_t arg2 ;
4836  void *argp1 = 0 ;
4837  int res1 = 0 ;
4838  unsigned int val2 ;
4839  int ecode2 = 0 ;
4840  PyObject * obj0 = 0 ;
4841  PyObject * obj1 = 0 ;
4842 
4843  if (!PyArg_ParseTuple(args,(char *)"OO:RouteCollisionEvent_peer_bgp_id_set",&obj0,&obj1)) SWIG_fail;
4844  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__RouteCollisionEvent, 0 | 0 );
4845  if (!SWIG_IsOK(res1)) {
4846  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RouteCollisionEvent_peer_bgp_id_set" "', argument " "1"" of type '" "libbgp::RouteCollisionEvent *""'");
4847  }
4848  arg1 = reinterpret_cast< libbgp::RouteCollisionEvent * >(argp1);
4849  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4850  if (!SWIG_IsOK(ecode2)) {
4851  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RouteCollisionEvent_peer_bgp_id_set" "', argument " "2"" of type '" "uint32_t""'");
4852  }
4853  arg2 = static_cast< uint32_t >(val2);
4854  if (arg1) (arg1)->peer_bgp_id = arg2;
4855  resultobj = SWIG_Py_Void();
4856  return resultobj;
4857 fail:
4858  return NULL;
4859 }
4860 
4861 
4862 SWIGINTERN PyObject *_wrap_RouteCollisionEvent_peer_bgp_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4863  PyObject *resultobj = 0;
4865  void *argp1 = 0 ;
4866  int res1 = 0 ;
4867  PyObject * obj0 = 0 ;
4868  uint32_t result;
4869 
4870  if (!PyArg_ParseTuple(args,(char *)"O:RouteCollisionEvent_peer_bgp_id_get",&obj0)) SWIG_fail;
4871  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__RouteCollisionEvent, 0 | 0 );
4872  if (!SWIG_IsOK(res1)) {
4873  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RouteCollisionEvent_peer_bgp_id_get" "', argument " "1"" of type '" "libbgp::RouteCollisionEvent *""'");
4874  }
4875  arg1 = reinterpret_cast< libbgp::RouteCollisionEvent * >(argp1);
4876  result = (uint32_t) ((arg1)->peer_bgp_id);
4877  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
4878  return resultobj;
4879 fail:
4880  return NULL;
4881 }
4882 
4883 
4884 SWIGINTERN PyObject *_wrap_delete_RouteCollisionEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4885  PyObject *resultobj = 0;
4887  void *argp1 = 0 ;
4888  int res1 = 0 ;
4889  PyObject * obj0 = 0 ;
4890 
4891  if (!PyArg_ParseTuple(args,(char *)"O:delete_RouteCollisionEvent",&obj0)) SWIG_fail;
4892  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__RouteCollisionEvent, SWIG_POINTER_DISOWN | 0 );
4893  if (!SWIG_IsOK(res1)) {
4894  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RouteCollisionEvent" "', argument " "1"" of type '" "libbgp::RouteCollisionEvent *""'");
4895  }
4896  arg1 = reinterpret_cast< libbgp::RouteCollisionEvent * >(argp1);
4897  delete arg1;
4898  resultobj = SWIG_Py_Void();
4899  return resultobj;
4900 fail:
4901  return NULL;
4902 }
4903 
4904 
4905 SWIGINTERN PyObject *RouteCollisionEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4906  PyObject *obj;
4907  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4908  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__RouteCollisionEvent, SWIG_NewClientData(obj));
4909  return SWIG_Py_Void();
4910 }
4911 
4912 SWIGINTERN PyObject *_wrap_delete_RouteEventReceiver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4913  PyObject *resultobj = 0;
4915  void *argp1 = 0 ;
4916  int res1 = 0 ;
4917  PyObject * obj0 = 0 ;
4918 
4919  if (!PyArg_ParseTuple(args,(char *)"O:delete_RouteEventReceiver",&obj0)) SWIG_fail;
4920  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__RouteEventReceiver, SWIG_POINTER_DISOWN | 0 );
4921  if (!SWIG_IsOK(res1)) {
4922  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RouteEventReceiver" "', argument " "1"" of type '" "libbgp::RouteEventReceiver *""'");
4923  }
4924  arg1 = reinterpret_cast< libbgp::RouteEventReceiver * >(argp1);
4925  delete arg1;
4926  resultobj = SWIG_Py_Void();
4927  return resultobj;
4928 fail:
4929  return NULL;
4930 }
4931 
4932 
4933 SWIGINTERN PyObject *RouteEventReceiver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4934  PyObject *obj;
4935  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4936  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__RouteEventReceiver, SWIG_NewClientData(obj));
4937  return SWIG_Py_Void();
4938 }
4939 
4940 SWIGINTERN PyObject *_wrap_new_RouteEventBus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4941  PyObject *resultobj = 0;
4942  libbgp::RouteEventBus *result = 0 ;
4943 
4944  if (!PyArg_ParseTuple(args,(char *)":new_RouteEventBus")) SWIG_fail;
4945  result = (libbgp::RouteEventBus *)new libbgp::RouteEventBus();
4946  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__RouteEventBus, SWIG_POINTER_NEW | 0 );
4947  return resultobj;
4948 fail:
4949  return NULL;
4950 }
4951 
4952 
4953 SWIGINTERN PyObject *_wrap_RouteEventBus_publish(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4954  PyObject *resultobj = 0;
4957  libbgp::RouteEvent *arg3 = 0 ;
4958  void *argp1 = 0 ;
4959  int res1 = 0 ;
4960  void *argp2 = 0 ;
4961  int res2 = 0 ;
4962  void *argp3 = 0 ;
4963  int res3 = 0 ;
4964  PyObject * obj0 = 0 ;
4965  PyObject * obj1 = 0 ;
4966  PyObject * obj2 = 0 ;
4967  int result;
4968 
4969  if (!PyArg_ParseTuple(args,(char *)"OOO:RouteEventBus_publish",&obj0,&obj1,&obj2)) SWIG_fail;
4970  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__RouteEventBus, 0 | 0 );
4971  if (!SWIG_IsOK(res1)) {
4972  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RouteEventBus_publish" "', argument " "1"" of type '" "libbgp::RouteEventBus *""'");
4973  }
4974  arg1 = reinterpret_cast< libbgp::RouteEventBus * >(argp1);
4975  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__RouteEventReceiver, 0 | 0 );
4976  if (!SWIG_IsOK(res2)) {
4977  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RouteEventBus_publish" "', argument " "2"" of type '" "libbgp::RouteEventReceiver *""'");
4978  }
4979  arg2 = reinterpret_cast< libbgp::RouteEventReceiver * >(argp2);
4980  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__RouteEvent, 0 | 0);
4981  if (!SWIG_IsOK(res3)) {
4982  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RouteEventBus_publish" "', argument " "3"" of type '" "libbgp::RouteEvent const &""'");
4983  }
4984  if (!argp3) {
4985  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RouteEventBus_publish" "', argument " "3"" of type '" "libbgp::RouteEvent const &""'");
4986  }
4987  arg3 = reinterpret_cast< libbgp::RouteEvent * >(argp3);
4988  result = (int)(arg1)->publish(arg2,(libbgp::RouteEvent const &)*arg3);
4989  resultobj = SWIG_From_int(static_cast< int >(result));
4990  return resultobj;
4991 fail:
4992  return NULL;
4993 }
4994 
4995 
4996 SWIGINTERN PyObject *_wrap_RouteEventBus_subscribe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4997  PyObject *resultobj = 0;
5000  void *argp1 = 0 ;
5001  int res1 = 0 ;
5002  void *argp2 = 0 ;
5003  int res2 = 0 ;
5004  PyObject * obj0 = 0 ;
5005  PyObject * obj1 = 0 ;
5006  bool result;
5007 
5008  if (!PyArg_ParseTuple(args,(char *)"OO:RouteEventBus_subscribe",&obj0,&obj1)) SWIG_fail;
5009  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__RouteEventBus, 0 | 0 );
5010  if (!SWIG_IsOK(res1)) {
5011  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RouteEventBus_subscribe" "', argument " "1"" of type '" "libbgp::RouteEventBus *""'");
5012  }
5013  arg1 = reinterpret_cast< libbgp::RouteEventBus * >(argp1);
5014  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__RouteEventReceiver, 0 | 0 );
5015  if (!SWIG_IsOK(res2)) {
5016  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RouteEventBus_subscribe" "', argument " "2"" of type '" "libbgp::RouteEventReceiver *""'");
5017  }
5018  arg2 = reinterpret_cast< libbgp::RouteEventReceiver * >(argp2);
5019  result = (bool)(arg1)->subscribe(arg2);
5020  resultobj = SWIG_From_bool(static_cast< bool >(result));
5021  return resultobj;
5022 fail:
5023  return NULL;
5024 }
5025 
5026 
5027 SWIGINTERN PyObject *_wrap_RouteEventBus_unsubscribe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5028  PyObject *resultobj = 0;
5031  void *argp1 = 0 ;
5032  int res1 = 0 ;
5033  void *argp2 = 0 ;
5034  int res2 = 0 ;
5035  PyObject * obj0 = 0 ;
5036  PyObject * obj1 = 0 ;
5037  bool result;
5038 
5039  if (!PyArg_ParseTuple(args,(char *)"OO:RouteEventBus_unsubscribe",&obj0,&obj1)) SWIG_fail;
5040  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__RouteEventBus, 0 | 0 );
5041  if (!SWIG_IsOK(res1)) {
5042  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RouteEventBus_unsubscribe" "', argument " "1"" of type '" "libbgp::RouteEventBus *""'");
5043  }
5044  arg1 = reinterpret_cast< libbgp::RouteEventBus * >(argp1);
5045  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__RouteEventReceiver, 0 | 0 );
5046  if (!SWIG_IsOK(res2)) {
5047  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RouteEventBus_unsubscribe" "', argument " "2"" of type '" "libbgp::RouteEventReceiver *""'");
5048  }
5049  arg2 = reinterpret_cast< libbgp::RouteEventReceiver * >(argp2);
5050  result = (bool)(arg1)->unsubscribe(arg2);
5051  resultobj = SWIG_From_bool(static_cast< bool >(result));
5052  return resultobj;
5053 fail:
5054  return NULL;
5055 }
5056 
5057 
5058 SWIGINTERN PyObject *_wrap_delete_RouteEventBus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5059  PyObject *resultobj = 0;
5061  void *argp1 = 0 ;
5062  int res1 = 0 ;
5063  PyObject * obj0 = 0 ;
5064 
5065  if (!PyArg_ParseTuple(args,(char *)"O:delete_RouteEventBus",&obj0)) SWIG_fail;
5066  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__RouteEventBus, SWIG_POINTER_DISOWN | 0 );
5067  if (!SWIG_IsOK(res1)) {
5068  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RouteEventBus" "', argument " "1"" of type '" "libbgp::RouteEventBus *""'");
5069  }
5070  arg1 = reinterpret_cast< libbgp::RouteEventBus * >(argp1);
5071  delete arg1;
5072  resultobj = SWIG_Py_Void();
5073  return resultobj;
5074 fail:
5075  return NULL;
5076 }
5077 
5078 
5079 SWIGINTERN PyObject *RouteEventBus_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5080  PyObject *obj;
5081  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5082  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__RouteEventBus, SWIG_NewClientData(obj));
5083  return SWIG_Py_Void();
5084 }
5085 
5086 SWIGINTERN PyObject *_wrap_cidr_to_mask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5087  PyObject *resultobj = 0;
5088  uint8_t arg1 ;
5089  unsigned char val1 ;
5090  int ecode1 = 0 ;
5091  PyObject * obj0 = 0 ;
5092  uint32_t result;
5093 
5094  if (!PyArg_ParseTuple(args,(char *)"O:cidr_to_mask",&obj0)) SWIG_fail;
5095  ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
5096  if (!SWIG_IsOK(ecode1)) {
5097  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cidr_to_mask" "', argument " "1"" of type '" "uint8_t""'");
5098  }
5099  arg1 = static_cast< uint8_t >(val1);
5100  result = (uint32_t)libbgp::cidr_to_mask(arg1);
5101  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
5102  return resultobj;
5103 fail:
5104  return NULL;
5105 }
5106 
5107 
5108 SWIGINTERN PyObject *_wrap_Prefix_afi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5109  PyObject *resultobj = 0;
5110  libbgp::Prefix *arg1 = (libbgp::Prefix *) 0 ;
5111  Afi arg2 ;
5112  void *argp1 = 0 ;
5113  int res1 = 0 ;
5114  void *argp2 ;
5115  int res2 = 0 ;
5116  PyObject * obj0 = 0 ;
5117  PyObject * obj1 = 0 ;
5118 
5119  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix_afi_set",&obj0,&obj1)) SWIG_fail;
5120  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix, 0 | 0 );
5121  if (!SWIG_IsOK(res1)) {
5122  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix_afi_set" "', argument " "1"" of type '" "libbgp::Prefix *""'");
5123  }
5124  arg1 = reinterpret_cast< libbgp::Prefix * >(argp1);
5125  {
5126  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_Afi, 0 | 0);
5127  if (!SWIG_IsOK(res2)) {
5128  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix_afi_set" "', argument " "2"" of type '" "Afi""'");
5129  }
5130  if (!argp2) {
5131  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix_afi_set" "', argument " "2"" of type '" "Afi""'");
5132  } else {
5133  Afi * temp = reinterpret_cast< Afi * >(argp2);
5134  arg2 = *temp;
5135  if (SWIG_IsNewObj(res2)) delete temp;
5136  }
5137  }
5138  if (arg1) (arg1)->afi = arg2;
5139  resultobj = SWIG_Py_Void();
5140  return resultobj;
5141 fail:
5142  return NULL;
5143 }
5144 
5145 
5146 SWIGINTERN PyObject *_wrap_Prefix_afi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5147  PyObject *resultobj = 0;
5148  libbgp::Prefix *arg1 = (libbgp::Prefix *) 0 ;
5149  void *argp1 = 0 ;
5150  int res1 = 0 ;
5151  PyObject * obj0 = 0 ;
5152  Afi result;
5153 
5154  if (!PyArg_ParseTuple(args,(char *)"O:Prefix_afi_get",&obj0)) SWIG_fail;
5155  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix, 0 | 0 );
5156  if (!SWIG_IsOK(res1)) {
5157  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix_afi_get" "', argument " "1"" of type '" "libbgp::Prefix *""'");
5158  }
5159  arg1 = reinterpret_cast< libbgp::Prefix * >(argp1);
5160  result = ((arg1)->afi);
5161  resultobj = SWIG_NewPointerObj((new Afi(static_cast< const Afi& >(result))), SWIGTYPE_p_Afi, SWIG_POINTER_OWN | 0 );
5162  return resultobj;
5163 fail:
5164  return NULL;
5165 }
5166 
5167 
5168 SWIGINTERN PyObject *_wrap_Prefix_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5169  PyObject *resultobj = 0;
5170  libbgp::Prefix *arg1 = (libbgp::Prefix *) 0 ;
5171  uint8_t *arg2 = (uint8_t *) 0 ;
5172  size_t arg3 ;
5173  void *argp1 = 0 ;
5174  int res1 = 0 ;
5175  void *argp2 = 0 ;
5176  int res2 = 0 ;
5177  size_t val3 ;
5178  int ecode3 = 0 ;
5179  PyObject * obj0 = 0 ;
5180  PyObject * obj1 = 0 ;
5181  PyObject * obj2 = 0 ;
5182  ssize_t result;
5183 
5184  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix_parse",&obj0,&obj1,&obj2)) SWIG_fail;
5185  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix, 0 | 0 );
5186  if (!SWIG_IsOK(res1)) {
5187  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix_parse" "', argument " "1"" of type '" "libbgp::Prefix *""'");
5188  }
5189  arg1 = reinterpret_cast< libbgp::Prefix * >(argp1);
5190  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
5191  if (!SWIG_IsOK(res2)) {
5192  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix_parse" "', argument " "2"" of type '" "uint8_t const *""'");
5193  }
5194  arg2 = reinterpret_cast< uint8_t * >(argp2);
5195  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
5196  if (!SWIG_IsOK(ecode3)) {
5197  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Prefix_parse" "', argument " "3"" of type '" "size_t""'");
5198  }
5199  arg3 = static_cast< size_t >(val3);
5200  result = (arg1)->parse((uint8_t const *)arg2,arg3);
5201  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
5202  return resultobj;
5203 fail:
5204  return NULL;
5205 }
5206 
5207 
5208 SWIGINTERN PyObject *_wrap_Prefix_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5209  PyObject *resultobj = 0;
5210  libbgp::Prefix *arg1 = (libbgp::Prefix *) 0 ;
5211  uint8_t *arg2 = (uint8_t *) 0 ;
5212  size_t arg3 ;
5213  void *argp1 = 0 ;
5214  int res1 = 0 ;
5215  void *argp2 = 0 ;
5216  int res2 = 0 ;
5217  size_t val3 ;
5218  int ecode3 = 0 ;
5219  PyObject * obj0 = 0 ;
5220  PyObject * obj1 = 0 ;
5221  PyObject * obj2 = 0 ;
5222  ssize_t result;
5223 
5224  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix_write",&obj0,&obj1,&obj2)) SWIG_fail;
5225  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix, 0 | 0 );
5226  if (!SWIG_IsOK(res1)) {
5227  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix_write" "', argument " "1"" of type '" "libbgp::Prefix const *""'");
5228  }
5229  arg1 = reinterpret_cast< libbgp::Prefix * >(argp1);
5230  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
5231  if (!SWIG_IsOK(res2)) {
5232  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix_write" "', argument " "2"" of type '" "uint8_t *""'");
5233  }
5234  arg2 = reinterpret_cast< uint8_t * >(argp2);
5235  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
5236  if (!SWIG_IsOK(ecode3)) {
5237  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Prefix_write" "', argument " "3"" of type '" "size_t""'");
5238  }
5239  arg3 = static_cast< size_t >(val3);
5240  result = ((libbgp::Prefix const *)arg1)->write(arg2,arg3);
5241  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
5242  return resultobj;
5243 fail:
5244  return NULL;
5245 }
5246 
5247 
5248 SWIGINTERN PyObject *_wrap_Prefix_includes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5249  PyObject *resultobj = 0;
5250  libbgp::Prefix *arg1 = (libbgp::Prefix *) 0 ;
5251  libbgp::Prefix *arg2 = 0 ;
5252  void *argp1 = 0 ;
5253  int res1 = 0 ;
5254  void *argp2 = 0 ;
5255  int res2 = 0 ;
5256  PyObject * obj0 = 0 ;
5257  PyObject * obj1 = 0 ;
5258  bool result;
5259 
5260  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix_includes",&obj0,&obj1)) SWIG_fail;
5261  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix, 0 | 0 );
5262  if (!SWIG_IsOK(res1)) {
5263  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix_includes" "', argument " "1"" of type '" "libbgp::Prefix const *""'");
5264  }
5265  arg1 = reinterpret_cast< libbgp::Prefix * >(argp1);
5266  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
5267  if (!SWIG_IsOK(res2)) {
5268  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix_includes" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5269  }
5270  if (!argp2) {
5271  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix_includes" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5272  }
5273  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
5274  result = (bool)((libbgp::Prefix const *)arg1)->includes((libbgp::Prefix const &)*arg2);
5275  resultobj = SWIG_From_bool(static_cast< bool >(result));
5276  return resultobj;
5277 fail:
5278  return NULL;
5279 }
5280 
5281 
5282 SWIGINTERN PyObject *_wrap_Prefix___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5283  PyObject *resultobj = 0;
5284  libbgp::Prefix *arg1 = (libbgp::Prefix *) 0 ;
5285  libbgp::Prefix *arg2 = 0 ;
5286  void *argp1 = 0 ;
5287  int res1 = 0 ;
5288  void *argp2 = 0 ;
5289  int res2 = 0 ;
5290  PyObject * obj0 = 0 ;
5291  PyObject * obj1 = 0 ;
5292  bool result;
5293 
5294  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix___eq__",&obj0,&obj1)) SWIG_fail;
5295  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix, 0 | 0 );
5296  if (!SWIG_IsOK(res1)) {
5297  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix___eq__" "', argument " "1"" of type '" "libbgp::Prefix const *""'");
5298  }
5299  arg1 = reinterpret_cast< libbgp::Prefix * >(argp1);
5300  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
5301  if (!SWIG_IsOK(res2)) {
5302  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix___eq__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5303  }
5304  if (!argp2) {
5305  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix___eq__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5306  }
5307  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
5308  result = (bool)((libbgp::Prefix const *)arg1)->operator ==((libbgp::Prefix const &)*arg2);
5309  resultobj = SWIG_From_bool(static_cast< bool >(result));
5310  return resultobj;
5311 fail:
5312  return NULL;
5313 }
5314 
5315 
5316 SWIGINTERN PyObject *_wrap_Prefix___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5317  PyObject *resultobj = 0;
5318  libbgp::Prefix *arg1 = (libbgp::Prefix *) 0 ;
5319  libbgp::Prefix *arg2 = 0 ;
5320  void *argp1 = 0 ;
5321  int res1 = 0 ;
5322  void *argp2 = 0 ;
5323  int res2 = 0 ;
5324  PyObject * obj0 = 0 ;
5325  PyObject * obj1 = 0 ;
5326  bool result;
5327 
5328  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix___gt__",&obj0,&obj1)) SWIG_fail;
5329  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix, 0 | 0 );
5330  if (!SWIG_IsOK(res1)) {
5331  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix___gt__" "', argument " "1"" of type '" "libbgp::Prefix const *""'");
5332  }
5333  arg1 = reinterpret_cast< libbgp::Prefix * >(argp1);
5334  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
5335  if (!SWIG_IsOK(res2)) {
5336  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix___gt__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5337  }
5338  if (!argp2) {
5339  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix___gt__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5340  }
5341  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
5342  result = (bool)((libbgp::Prefix const *)arg1)->operator >((libbgp::Prefix const &)*arg2);
5343  resultobj = SWIG_From_bool(static_cast< bool >(result));
5344  return resultobj;
5345 fail:
5346  return NULL;
5347 }
5348 
5349 
5350 SWIGINTERN PyObject *_wrap_Prefix___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5351  PyObject *resultobj = 0;
5352  libbgp::Prefix *arg1 = (libbgp::Prefix *) 0 ;
5353  libbgp::Prefix *arg2 = 0 ;
5354  void *argp1 = 0 ;
5355  int res1 = 0 ;
5356  void *argp2 = 0 ;
5357  int res2 = 0 ;
5358  PyObject * obj0 = 0 ;
5359  PyObject * obj1 = 0 ;
5360  bool result;
5361 
5362  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix___lt__",&obj0,&obj1)) SWIG_fail;
5363  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix, 0 | 0 );
5364  if (!SWIG_IsOK(res1)) {
5365  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix___lt__" "', argument " "1"" of type '" "libbgp::Prefix const *""'");
5366  }
5367  arg1 = reinterpret_cast< libbgp::Prefix * >(argp1);
5368  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
5369  if (!SWIG_IsOK(res2)) {
5370  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix___lt__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5371  }
5372  if (!argp2) {
5373  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix___lt__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5374  }
5375  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
5376  result = (bool)((libbgp::Prefix const *)arg1)->operator <((libbgp::Prefix const &)*arg2);
5377  resultobj = SWIG_From_bool(static_cast< bool >(result));
5378  return resultobj;
5379 fail:
5380  return NULL;
5381 }
5382 
5383 
5384 SWIGINTERN PyObject *_wrap_Prefix___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5385  PyObject *resultobj = 0;
5386  libbgp::Prefix *arg1 = (libbgp::Prefix *) 0 ;
5387  libbgp::Prefix *arg2 = 0 ;
5388  void *argp1 = 0 ;
5389  int res1 = 0 ;
5390  void *argp2 = 0 ;
5391  int res2 = 0 ;
5392  PyObject * obj0 = 0 ;
5393  PyObject * obj1 = 0 ;
5394  bool result;
5395 
5396  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix___ge__",&obj0,&obj1)) SWIG_fail;
5397  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix, 0 | 0 );
5398  if (!SWIG_IsOK(res1)) {
5399  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix___ge__" "', argument " "1"" of type '" "libbgp::Prefix const *""'");
5400  }
5401  arg1 = reinterpret_cast< libbgp::Prefix * >(argp1);
5402  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
5403  if (!SWIG_IsOK(res2)) {
5404  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix___ge__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5405  }
5406  if (!argp2) {
5407  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix___ge__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5408  }
5409  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
5410  result = (bool)((libbgp::Prefix const *)arg1)->operator >=((libbgp::Prefix const &)*arg2);
5411  resultobj = SWIG_From_bool(static_cast< bool >(result));
5412  return resultobj;
5413 fail:
5414  return NULL;
5415 }
5416 
5417 
5418 SWIGINTERN PyObject *_wrap_Prefix___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5419  PyObject *resultobj = 0;
5420  libbgp::Prefix *arg1 = (libbgp::Prefix *) 0 ;
5421  libbgp::Prefix *arg2 = 0 ;
5422  void *argp1 = 0 ;
5423  int res1 = 0 ;
5424  void *argp2 = 0 ;
5425  int res2 = 0 ;
5426  PyObject * obj0 = 0 ;
5427  PyObject * obj1 = 0 ;
5428  bool result;
5429 
5430  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix___le__",&obj0,&obj1)) SWIG_fail;
5431  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix, 0 | 0 );
5432  if (!SWIG_IsOK(res1)) {
5433  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix___le__" "', argument " "1"" of type '" "libbgp::Prefix const *""'");
5434  }
5435  arg1 = reinterpret_cast< libbgp::Prefix * >(argp1);
5436  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
5437  if (!SWIG_IsOK(res2)) {
5438  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix___le__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5439  }
5440  if (!argp2) {
5441  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix___le__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5442  }
5443  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
5444  result = (bool)((libbgp::Prefix const *)arg1)->operator <=((libbgp::Prefix const &)*arg2);
5445  resultobj = SWIG_From_bool(static_cast< bool >(result));
5446  return resultobj;
5447 fail:
5448  return NULL;
5449 }
5450 
5451 
5452 SWIGINTERN PyObject *_wrap_Prefix___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5453  PyObject *resultobj = 0;
5454  libbgp::Prefix *arg1 = (libbgp::Prefix *) 0 ;
5455  libbgp::Prefix *arg2 = 0 ;
5456  void *argp1 = 0 ;
5457  int res1 = 0 ;
5458  void *argp2 = 0 ;
5459  int res2 = 0 ;
5460  PyObject * obj0 = 0 ;
5461  PyObject * obj1 = 0 ;
5462  bool result;
5463 
5464  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix___ne__",&obj0,&obj1)) SWIG_fail;
5465  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix, 0 | 0 );
5466  if (!SWIG_IsOK(res1)) {
5467  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix___ne__" "', argument " "1"" of type '" "libbgp::Prefix const *""'");
5468  }
5469  arg1 = reinterpret_cast< libbgp::Prefix * >(argp1);
5470  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
5471  if (!SWIG_IsOK(res2)) {
5472  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix___ne__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5473  }
5474  if (!argp2) {
5475  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix___ne__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5476  }
5477  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
5478  result = (bool)((libbgp::Prefix const *)arg1)->operator !=((libbgp::Prefix const &)*arg2);
5479  resultobj = SWIG_From_bool(static_cast< bool >(result));
5480  return resultobj;
5481 fail:
5482  return NULL;
5483 }
5484 
5485 
5486 SWIGINTERN PyObject *_wrap_delete_Prefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5487  PyObject *resultobj = 0;
5488  libbgp::Prefix *arg1 = (libbgp::Prefix *) 0 ;
5489  void *argp1 = 0 ;
5490  int res1 = 0 ;
5491  PyObject * obj0 = 0 ;
5492 
5493  if (!PyArg_ParseTuple(args,(char *)"O:delete_Prefix",&obj0)) SWIG_fail;
5494  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix, SWIG_POINTER_DISOWN | 0 );
5495  if (!SWIG_IsOK(res1)) {
5496  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Prefix" "', argument " "1"" of type '" "libbgp::Prefix *""'");
5497  }
5498  arg1 = reinterpret_cast< libbgp::Prefix * >(argp1);
5499  delete arg1;
5500  resultobj = SWIG_Py_Void();
5501  return resultobj;
5502 fail:
5503  return NULL;
5504 }
5505 
5506 
5507 SWIGINTERN PyObject *Prefix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5508  PyObject *obj;
5509  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5510  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__Prefix, SWIG_NewClientData(obj));
5511  return SWIG_Py_Void();
5512 }
5513 
5514 SWIGINTERN PyObject *_wrap_new_Prefix4__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5515  PyObject *resultobj = 0;
5516  libbgp::Prefix4 *result = 0 ;
5517 
5518  if (!PyArg_ParseTuple(args,(char *)":new_Prefix4")) SWIG_fail;
5519  result = (libbgp::Prefix4 *)new libbgp::Prefix4();
5520  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Prefix4, SWIG_POINTER_NEW | 0 );
5521  return resultobj;
5522 fail:
5523  return NULL;
5524 }
5525 
5526 
5527 SWIGINTERN PyObject *_wrap_new_Prefix4__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5528  PyObject *resultobj = 0;
5529  uint32_t arg1 ;
5530  uint8_t arg2 ;
5531  unsigned int val1 ;
5532  int ecode1 = 0 ;
5533  unsigned char val2 ;
5534  int ecode2 = 0 ;
5535  PyObject * obj0 = 0 ;
5536  PyObject * obj1 = 0 ;
5537  libbgp::Prefix4 *result = 0 ;
5538 
5539  if (!PyArg_ParseTuple(args,(char *)"OO:new_Prefix4",&obj0,&obj1)) SWIG_fail;
5540  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
5541  if (!SWIG_IsOK(ecode1)) {
5542  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Prefix4" "', argument " "1"" of type '" "uint32_t""'");
5543  }
5544  arg1 = static_cast< uint32_t >(val1);
5545  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
5546  if (!SWIG_IsOK(ecode2)) {
5547  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Prefix4" "', argument " "2"" of type '" "uint8_t""'");
5548  }
5549  arg2 = static_cast< uint8_t >(val2);
5550  result = (libbgp::Prefix4 *)new libbgp::Prefix4(arg1,arg2);
5551  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Prefix4, SWIG_POINTER_NEW | 0 );
5552  return resultobj;
5553 fail:
5554  return NULL;
5555 }
5556 
5557 
5558 SWIGINTERN PyObject *_wrap_new_Prefix4__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5559  PyObject *resultobj = 0;
5560  char *arg1 = (char *) 0 ;
5561  uint8_t arg2 ;
5562  int res1 ;
5563  char *buf1 = 0 ;
5564  int alloc1 = 0 ;
5565  unsigned char val2 ;
5566  int ecode2 = 0 ;
5567  PyObject * obj0 = 0 ;
5568  PyObject * obj1 = 0 ;
5569  libbgp::Prefix4 *result = 0 ;
5570 
5571  if (!PyArg_ParseTuple(args,(char *)"OO:new_Prefix4",&obj0,&obj1)) SWIG_fail;
5572  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5573  if (!SWIG_IsOK(res1)) {
5574  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Prefix4" "', argument " "1"" of type '" "char const *""'");
5575  }
5576  arg1 = reinterpret_cast< char * >(buf1);
5577  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
5578  if (!SWIG_IsOK(ecode2)) {
5579  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Prefix4" "', argument " "2"" of type '" "uint8_t""'");
5580  }
5581  arg2 = static_cast< uint8_t >(val2);
5582  result = (libbgp::Prefix4 *)new libbgp::Prefix4((char const *)arg1,arg2);
5583  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Prefix4, SWIG_POINTER_NEW | 0 );
5584  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
5585  return resultobj;
5586 fail:
5587  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
5588  return NULL;
5589 }
5590 
5591 
5592 SWIGINTERN PyObject *_wrap_new_Prefix4(PyObject *self, PyObject *args) {
5593  Py_ssize_t argc;
5594  PyObject *argv[3] = {
5595  0
5596  };
5597  Py_ssize_t ii;
5598 
5599  if (!PyTuple_Check(args)) SWIG_fail;
5600  argc = args ? PyObject_Length(args) : 0;
5601  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
5602  argv[ii] = PyTuple_GET_ITEM(args,ii);
5603  }
5604  if (argc == 0) {
5605  return _wrap_new_Prefix4__SWIG_0(self, args);
5606  }
5607  if (argc == 2) {
5608  int _v;
5609  {
5610  int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
5611  _v = SWIG_CheckState(res);
5612  }
5613  if (_v) {
5614  {
5615  int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
5616  _v = SWIG_CheckState(res);
5617  }
5618  if (_v) {
5619  return _wrap_new_Prefix4__SWIG_1(self, args);
5620  }
5621  }
5622  }
5623  if (argc == 2) {
5624  int _v;
5625  int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
5626  _v = SWIG_CheckState(res);
5627  if (_v) {
5628  {
5629  int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
5630  _v = SWIG_CheckState(res);
5631  }
5632  if (_v) {
5633  return _wrap_new_Prefix4__SWIG_2(self, args);
5634  }
5635  }
5636  }
5637 
5638 fail:
5639  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Prefix4'.\n"
5640  " Possible C/C++ prototypes are:\n"
5641  " libbgp::Prefix4::Prefix4()\n"
5642  " libbgp::Prefix4::Prefix4(uint32_t,uint8_t)\n"
5643  " libbgp::Prefix4::Prefix4(char const *,uint8_t)\n");
5644  return 0;
5645 }
5646 
5647 
5648 SWIGINTERN PyObject *_wrap_Prefix4_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5649  PyObject *resultobj = 0;
5650  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
5651  uint8_t *arg2 = (uint8_t *) 0 ;
5652  size_t arg3 ;
5653  void *argp1 = 0 ;
5654  int res1 = 0 ;
5655  void *argp2 = 0 ;
5656  int res2 = 0 ;
5657  size_t val3 ;
5658  int ecode3 = 0 ;
5659  PyObject * obj0 = 0 ;
5660  PyObject * obj1 = 0 ;
5661  PyObject * obj2 = 0 ;
5662  ssize_t result;
5663 
5664  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix4_parse",&obj0,&obj1,&obj2)) SWIG_fail;
5665  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
5666  if (!SWIG_IsOK(res1)) {
5667  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4_parse" "', argument " "1"" of type '" "libbgp::Prefix4 *""'");
5668  }
5669  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
5670  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
5671  if (!SWIG_IsOK(res2)) {
5672  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix4_parse" "', argument " "2"" of type '" "uint8_t const *""'");
5673  }
5674  arg2 = reinterpret_cast< uint8_t * >(argp2);
5675  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
5676  if (!SWIG_IsOK(ecode3)) {
5677  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Prefix4_parse" "', argument " "3"" of type '" "size_t""'");
5678  }
5679  arg3 = static_cast< size_t >(val3);
5680  result = (arg1)->parse((uint8_t const *)arg2,arg3);
5681  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
5682  return resultobj;
5683 fail:
5684  return NULL;
5685 }
5686 
5687 
5688 SWIGINTERN PyObject *_wrap_Prefix4_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5689  PyObject *resultobj = 0;
5690  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
5691  uint8_t *arg2 = (uint8_t *) 0 ;
5692  size_t arg3 ;
5693  void *argp1 = 0 ;
5694  int res1 = 0 ;
5695  void *argp2 = 0 ;
5696  int res2 = 0 ;
5697  size_t val3 ;
5698  int ecode3 = 0 ;
5699  PyObject * obj0 = 0 ;
5700  PyObject * obj1 = 0 ;
5701  PyObject * obj2 = 0 ;
5702  ssize_t result;
5703 
5704  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix4_write",&obj0,&obj1,&obj2)) SWIG_fail;
5705  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
5706  if (!SWIG_IsOK(res1)) {
5707  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4_write" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
5708  }
5709  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
5710  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
5711  if (!SWIG_IsOK(res2)) {
5712  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix4_write" "', argument " "2"" of type '" "uint8_t *""'");
5713  }
5714  arg2 = reinterpret_cast< uint8_t * >(argp2);
5715  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
5716  if (!SWIG_IsOK(ecode3)) {
5717  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Prefix4_write" "', argument " "3"" of type '" "size_t""'");
5718  }
5719  arg3 = static_cast< size_t >(val3);
5720  result = ((libbgp::Prefix4 const *)arg1)->write(arg2,arg3);
5721  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
5722  return resultobj;
5723 fail:
5724  return NULL;
5725 }
5726 
5727 
5728 SWIGINTERN PyObject *_wrap_Prefix4_Includes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5729  PyObject *resultobj = 0;
5730  uint32_t arg1 ;
5731  uint8_t arg2 ;
5732  uint32_t arg3 ;
5733  unsigned int val1 ;
5734  int ecode1 = 0 ;
5735  unsigned char val2 ;
5736  int ecode2 = 0 ;
5737  unsigned int val3 ;
5738  int ecode3 = 0 ;
5739  PyObject * obj0 = 0 ;
5740  PyObject * obj1 = 0 ;
5741  PyObject * obj2 = 0 ;
5742  bool result;
5743 
5744  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix4_Includes",&obj0,&obj1,&obj2)) SWIG_fail;
5745  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
5746  if (!SWIG_IsOK(ecode1)) {
5747  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Prefix4_Includes" "', argument " "1"" of type '" "uint32_t""'");
5748  }
5749  arg1 = static_cast< uint32_t >(val1);
5750  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
5751  if (!SWIG_IsOK(ecode2)) {
5752  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Prefix4_Includes" "', argument " "2"" of type '" "uint8_t""'");
5753  }
5754  arg2 = static_cast< uint8_t >(val2);
5755  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
5756  if (!SWIG_IsOK(ecode3)) {
5757  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Prefix4_Includes" "', argument " "3"" of type '" "uint32_t""'");
5758  }
5759  arg3 = static_cast< uint32_t >(val3);
5760  result = (bool)libbgp::Prefix4::Includes(arg1,arg2,arg3);
5761  resultobj = SWIG_From_bool(static_cast< bool >(result));
5762  return resultobj;
5763 fail:
5764  return NULL;
5765 }
5766 
5767 
5768 SWIGINTERN PyObject *_wrap_Prefix4_Includes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5769  PyObject *resultobj = 0;
5770  uint32_t arg1 ;
5771  uint8_t arg2 ;
5772  uint32_t arg3 ;
5773  uint8_t arg4 ;
5774  unsigned int val1 ;
5775  int ecode1 = 0 ;
5776  unsigned char val2 ;
5777  int ecode2 = 0 ;
5778  unsigned int val3 ;
5779  int ecode3 = 0 ;
5780  unsigned char val4 ;
5781  int ecode4 = 0 ;
5782  PyObject * obj0 = 0 ;
5783  PyObject * obj1 = 0 ;
5784  PyObject * obj2 = 0 ;
5785  PyObject * obj3 = 0 ;
5786  bool result;
5787 
5788  if (!PyArg_ParseTuple(args,(char *)"OOOO:Prefix4_Includes",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5789  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
5790  if (!SWIG_IsOK(ecode1)) {
5791  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Prefix4_Includes" "', argument " "1"" of type '" "uint32_t""'");
5792  }
5793  arg1 = static_cast< uint32_t >(val1);
5794  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
5795  if (!SWIG_IsOK(ecode2)) {
5796  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Prefix4_Includes" "', argument " "2"" of type '" "uint8_t""'");
5797  }
5798  arg2 = static_cast< uint8_t >(val2);
5799  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
5800  if (!SWIG_IsOK(ecode3)) {
5801  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Prefix4_Includes" "', argument " "3"" of type '" "uint32_t""'");
5802  }
5803  arg3 = static_cast< uint32_t >(val3);
5804  ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
5805  if (!SWIG_IsOK(ecode4)) {
5806  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Prefix4_Includes" "', argument " "4"" of type '" "uint8_t""'");
5807  }
5808  arg4 = static_cast< uint8_t >(val4);
5809  result = (bool)libbgp::Prefix4::Includes(arg1,arg2,arg3,arg4);
5810  resultobj = SWIG_From_bool(static_cast< bool >(result));
5811  return resultobj;
5812 fail:
5813  return NULL;
5814 }
5815 
5816 
5817 SWIGINTERN PyObject *_wrap_Prefix4_Includes(PyObject *self, PyObject *args) {
5818  Py_ssize_t argc;
5819  PyObject *argv[5] = {
5820  0
5821  };
5822  Py_ssize_t ii;
5823 
5824  if (!PyTuple_Check(args)) SWIG_fail;
5825  argc = args ? PyObject_Length(args) : 0;
5826  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
5827  argv[ii] = PyTuple_GET_ITEM(args,ii);
5828  }
5829  if (argc == 3) {
5830  int _v;
5831  {
5832  int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
5833  _v = SWIG_CheckState(res);
5834  }
5835  if (_v) {
5836  {
5837  int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
5838  _v = SWIG_CheckState(res);
5839  }
5840  if (_v) {
5841  {
5842  int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
5843  _v = SWIG_CheckState(res);
5844  }
5845  if (_v) {
5846  return _wrap_Prefix4_Includes__SWIG_0(self, args);
5847  }
5848  }
5849  }
5850  }
5851  if (argc == 4) {
5852  int _v;
5853  {
5854  int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
5855  _v = SWIG_CheckState(res);
5856  }
5857  if (_v) {
5858  {
5859  int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
5860  _v = SWIG_CheckState(res);
5861  }
5862  if (_v) {
5863  {
5864  int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
5865  _v = SWIG_CheckState(res);
5866  }
5867  if (_v) {
5868  {
5869  int res = SWIG_AsVal_unsigned_SS_char(argv[3], NULL);
5870  _v = SWIG_CheckState(res);
5871  }
5872  if (_v) {
5873  return _wrap_Prefix4_Includes__SWIG_1(self, args);
5874  }
5875  }
5876  }
5877  }
5878  }
5879 
5880 fail:
5881  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Prefix4_Includes'.\n"
5882  " Possible C/C++ prototypes are:\n"
5883  " libbgp::Prefix4::Includes(uint32_t,uint8_t,uint32_t)\n"
5884  " libbgp::Prefix4::Includes(uint32_t,uint8_t,uint32_t,uint8_t)\n");
5885  return 0;
5886 }
5887 
5888 
5889 SWIGINTERN PyObject *_wrap_Prefix4_includes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5890  PyObject *resultobj = 0;
5891  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
5892  uint32_t arg2 ;
5893  void *argp1 = 0 ;
5894  int res1 = 0 ;
5895  unsigned int val2 ;
5896  int ecode2 = 0 ;
5897  PyObject * obj0 = 0 ;
5898  PyObject * obj1 = 0 ;
5899  bool result;
5900 
5901  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix4_includes",&obj0,&obj1)) SWIG_fail;
5902  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
5903  if (!SWIG_IsOK(res1)) {
5904  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4_includes" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
5905  }
5906  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
5907  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5908  if (!SWIG_IsOK(ecode2)) {
5909  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Prefix4_includes" "', argument " "2"" of type '" "uint32_t""'");
5910  }
5911  arg2 = static_cast< uint32_t >(val2);
5912  result = (bool)((libbgp::Prefix4 const *)arg1)->includes(arg2);
5913  resultobj = SWIG_From_bool(static_cast< bool >(result));
5914  return resultobj;
5915 fail:
5916  return NULL;
5917 }
5918 
5919 
5920 SWIGINTERN PyObject *_wrap_Prefix4_includes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5921  PyObject *resultobj = 0;
5922  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
5923  char *arg2 = (char *) 0 ;
5924  void *argp1 = 0 ;
5925  int res1 = 0 ;
5926  int res2 ;
5927  char *buf2 = 0 ;
5928  int alloc2 = 0 ;
5929  PyObject * obj0 = 0 ;
5930  PyObject * obj1 = 0 ;
5931  bool result;
5932 
5933  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix4_includes",&obj0,&obj1)) SWIG_fail;
5934  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
5935  if (!SWIG_IsOK(res1)) {
5936  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4_includes" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
5937  }
5938  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
5939  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5940  if (!SWIG_IsOK(res2)) {
5941  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix4_includes" "', argument " "2"" of type '" "char const *""'");
5942  }
5943  arg2 = reinterpret_cast< char * >(buf2);
5944  result = (bool)((libbgp::Prefix4 const *)arg1)->includes((char const *)arg2);
5945  resultobj = SWIG_From_bool(static_cast< bool >(result));
5946  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5947  return resultobj;
5948 fail:
5949  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
5950  return NULL;
5951 }
5952 
5953 
5954 SWIGINTERN PyObject *_wrap_Prefix4_includes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5955  PyObject *resultobj = 0;
5956  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
5957  libbgp::Prefix *arg2 = 0 ;
5958  void *argp1 = 0 ;
5959  int res1 = 0 ;
5960  void *argp2 = 0 ;
5961  int res2 = 0 ;
5962  PyObject * obj0 = 0 ;
5963  PyObject * obj1 = 0 ;
5964  bool result;
5965 
5966  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix4_includes",&obj0,&obj1)) SWIG_fail;
5967  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
5968  if (!SWIG_IsOK(res1)) {
5969  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4_includes" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
5970  }
5971  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
5972  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
5973  if (!SWIG_IsOK(res2)) {
5974  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix4_includes" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5975  }
5976  if (!argp2) {
5977  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix4_includes" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
5978  }
5979  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
5980  result = (bool)((libbgp::Prefix4 const *)arg1)->includes((libbgp::Prefix const &)*arg2);
5981  resultobj = SWIG_From_bool(static_cast< bool >(result));
5982  return resultobj;
5983 fail:
5984  return NULL;
5985 }
5986 
5987 
5988 SWIGINTERN PyObject *_wrap_Prefix4_includes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5989  PyObject *resultobj = 0;
5990  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
5991  uint32_t arg2 ;
5992  uint8_t arg3 ;
5993  void *argp1 = 0 ;
5994  int res1 = 0 ;
5995  unsigned int val2 ;
5996  int ecode2 = 0 ;
5997  unsigned char val3 ;
5998  int ecode3 = 0 ;
5999  PyObject * obj0 = 0 ;
6000  PyObject * obj1 = 0 ;
6001  PyObject * obj2 = 0 ;
6002  bool result;
6003 
6004  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix4_includes",&obj0,&obj1,&obj2)) SWIG_fail;
6005  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
6006  if (!SWIG_IsOK(res1)) {
6007  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4_includes" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
6008  }
6009  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6010  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6011  if (!SWIG_IsOK(ecode2)) {
6012  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Prefix4_includes" "', argument " "2"" of type '" "uint32_t""'");
6013  }
6014  arg2 = static_cast< uint32_t >(val2);
6015  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
6016  if (!SWIG_IsOK(ecode3)) {
6017  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Prefix4_includes" "', argument " "3"" of type '" "uint8_t""'");
6018  }
6019  arg3 = static_cast< uint8_t >(val3);
6020  result = (bool)((libbgp::Prefix4 const *)arg1)->includes(arg2,arg3);
6021  resultobj = SWIG_From_bool(static_cast< bool >(result));
6022  return resultobj;
6023 fail:
6024  return NULL;
6025 }
6026 
6027 
6028 SWIGINTERN PyObject *_wrap_Prefix4_includes__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6029  PyObject *resultobj = 0;
6030  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
6031  char *arg2 = (char *) 0 ;
6032  uint8_t arg3 ;
6033  void *argp1 = 0 ;
6034  int res1 = 0 ;
6035  int res2 ;
6036  char *buf2 = 0 ;
6037  int alloc2 = 0 ;
6038  unsigned char val3 ;
6039  int ecode3 = 0 ;
6040  PyObject * obj0 = 0 ;
6041  PyObject * obj1 = 0 ;
6042  PyObject * obj2 = 0 ;
6043  bool result;
6044 
6045  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix4_includes",&obj0,&obj1,&obj2)) SWIG_fail;
6046  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
6047  if (!SWIG_IsOK(res1)) {
6048  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4_includes" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
6049  }
6050  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6051  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
6052  if (!SWIG_IsOK(res2)) {
6053  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix4_includes" "', argument " "2"" of type '" "char const *""'");
6054  }
6055  arg2 = reinterpret_cast< char * >(buf2);
6056  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
6057  if (!SWIG_IsOK(ecode3)) {
6058  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Prefix4_includes" "', argument " "3"" of type '" "uint8_t""'");
6059  }
6060  arg3 = static_cast< uint8_t >(val3);
6061  result = (bool)((libbgp::Prefix4 const *)arg1)->includes((char const *)arg2,arg3);
6062  resultobj = SWIG_From_bool(static_cast< bool >(result));
6063  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6064  return resultobj;
6065 fail:
6066  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
6067  return NULL;
6068 }
6069 
6070 
6071 SWIGINTERN PyObject *_wrap_Prefix4_includes(PyObject *self, PyObject *args) {
6072  Py_ssize_t argc;
6073  PyObject *argv[4] = {
6074  0
6075  };
6076  Py_ssize_t ii;
6077 
6078  if (!PyTuple_Check(args)) SWIG_fail;
6079  argc = args ? PyObject_Length(args) : 0;
6080  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
6081  argv[ii] = PyTuple_GET_ITEM(args,ii);
6082  }
6083  if (argc == 2) {
6084  int _v;
6085  void *vptr = 0;
6086  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__Prefix4, 0);
6087  _v = SWIG_CheckState(res);
6088  if (_v) {
6089  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_libbgp__Prefix, 0);
6090  _v = SWIG_CheckState(res);
6091  if (_v) {
6092  return _wrap_Prefix4_includes__SWIG_2(self, args);
6093  }
6094  }
6095  }
6096  if (argc == 2) {
6097  int _v;
6098  void *vptr = 0;
6099  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__Prefix4, 0);
6100  _v = SWIG_CheckState(res);
6101  if (_v) {
6102  {
6103  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
6104  _v = SWIG_CheckState(res);
6105  }
6106  if (_v) {
6107  return _wrap_Prefix4_includes__SWIG_0(self, args);
6108  }
6109  }
6110  }
6111  if (argc == 2) {
6112  int _v;
6113  void *vptr = 0;
6114  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__Prefix4, 0);
6115  _v = SWIG_CheckState(res);
6116  if (_v) {
6117  int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
6118  _v = SWIG_CheckState(res);
6119  if (_v) {
6120  return _wrap_Prefix4_includes__SWIG_1(self, args);
6121  }
6122  }
6123  }
6124  if (argc == 3) {
6125  int _v;
6126  void *vptr = 0;
6127  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__Prefix4, 0);
6128  _v = SWIG_CheckState(res);
6129  if (_v) {
6130  {
6131  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
6132  _v = SWIG_CheckState(res);
6133  }
6134  if (_v) {
6135  {
6136  int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
6137  _v = SWIG_CheckState(res);
6138  }
6139  if (_v) {
6140  return _wrap_Prefix4_includes__SWIG_3(self, args);
6141  }
6142  }
6143  }
6144  }
6145  if (argc == 3) {
6146  int _v;
6147  void *vptr = 0;
6148  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__Prefix4, 0);
6149  _v = SWIG_CheckState(res);
6150  if (_v) {
6151  int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
6152  _v = SWIG_CheckState(res);
6153  if (_v) {
6154  {
6155  int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
6156  _v = SWIG_CheckState(res);
6157  }
6158  if (_v) {
6159  return _wrap_Prefix4_includes__SWIG_4(self, args);
6160  }
6161  }
6162  }
6163  }
6164 
6165 fail:
6166  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Prefix4_includes'.\n"
6167  " Possible C/C++ prototypes are:\n"
6168  " libbgp::Prefix4::includes(uint32_t) const\n"
6169  " libbgp::Prefix4::includes(char const *) const\n"
6170  " libbgp::Prefix4::includes(libbgp::Prefix const &) const\n"
6171  " libbgp::Prefix4::includes(uint32_t,uint8_t) const\n"
6172  " libbgp::Prefix4::includes(char const *,uint8_t) const\n");
6173  return 0;
6174 }
6175 
6176 
6177 SWIGINTERN PyObject *_wrap_Prefix4___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6178  PyObject *resultobj = 0;
6179  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
6180  libbgp::Prefix *arg2 = 0 ;
6181  void *argp1 = 0 ;
6182  int res1 = 0 ;
6183  void *argp2 = 0 ;
6184  int res2 = 0 ;
6185  PyObject * obj0 = 0 ;
6186  PyObject * obj1 = 0 ;
6187  bool result;
6188 
6189  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix4___eq__",&obj0,&obj1)) SWIG_fail;
6190  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
6191  if (!SWIG_IsOK(res1)) {
6192  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4___eq__" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
6193  }
6194  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6195  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
6196  if (!SWIG_IsOK(res2)) {
6197  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix4___eq__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
6198  }
6199  if (!argp2) {
6200  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix4___eq__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
6201  }
6202  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
6203  result = (bool)((libbgp::Prefix4 const *)arg1)->operator ==((libbgp::Prefix const &)*arg2);
6204  resultobj = SWIG_From_bool(static_cast< bool >(result));
6205  return resultobj;
6206 fail:
6207  return NULL;
6208 }
6209 
6210 
6211 SWIGINTERN PyObject *_wrap_Prefix4___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6212  PyObject *resultobj = 0;
6213  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
6214  libbgp::Prefix *arg2 = 0 ;
6215  void *argp1 = 0 ;
6216  int res1 = 0 ;
6217  void *argp2 = 0 ;
6218  int res2 = 0 ;
6219  PyObject * obj0 = 0 ;
6220  PyObject * obj1 = 0 ;
6221  bool result;
6222 
6223  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix4___gt__",&obj0,&obj1)) SWIG_fail;
6224  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
6225  if (!SWIG_IsOK(res1)) {
6226  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4___gt__" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
6227  }
6228  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6229  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
6230  if (!SWIG_IsOK(res2)) {
6231  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix4___gt__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
6232  }
6233  if (!argp2) {
6234  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix4___gt__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
6235  }
6236  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
6237  result = (bool)((libbgp::Prefix4 const *)arg1)->operator >((libbgp::Prefix const &)*arg2);
6238  resultobj = SWIG_From_bool(static_cast< bool >(result));
6239  return resultobj;
6240 fail:
6241  return NULL;
6242 }
6243 
6244 
6245 SWIGINTERN PyObject *_wrap_Prefix4___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6246  PyObject *resultobj = 0;
6247  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
6248  libbgp::Prefix *arg2 = 0 ;
6249  void *argp1 = 0 ;
6250  int res1 = 0 ;
6251  void *argp2 = 0 ;
6252  int res2 = 0 ;
6253  PyObject * obj0 = 0 ;
6254  PyObject * obj1 = 0 ;
6255  bool result;
6256 
6257  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix4___lt__",&obj0,&obj1)) SWIG_fail;
6258  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
6259  if (!SWIG_IsOK(res1)) {
6260  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4___lt__" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
6261  }
6262  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6263  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
6264  if (!SWIG_IsOK(res2)) {
6265  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix4___lt__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
6266  }
6267  if (!argp2) {
6268  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix4___lt__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
6269  }
6270  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
6271  result = (bool)((libbgp::Prefix4 const *)arg1)->operator <((libbgp::Prefix const &)*arg2);
6272  resultobj = SWIG_From_bool(static_cast< bool >(result));
6273  return resultobj;
6274 fail:
6275  return NULL;
6276 }
6277 
6278 
6279 SWIGINTERN PyObject *_wrap_Prefix4___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6280  PyObject *resultobj = 0;
6281  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
6282  libbgp::Prefix *arg2 = 0 ;
6283  void *argp1 = 0 ;
6284  int res1 = 0 ;
6285  void *argp2 = 0 ;
6286  int res2 = 0 ;
6287  PyObject * obj0 = 0 ;
6288  PyObject * obj1 = 0 ;
6289  bool result;
6290 
6291  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix4___ge__",&obj0,&obj1)) SWIG_fail;
6292  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
6293  if (!SWIG_IsOK(res1)) {
6294  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4___ge__" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
6295  }
6296  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6297  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
6298  if (!SWIG_IsOK(res2)) {
6299  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix4___ge__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
6300  }
6301  if (!argp2) {
6302  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix4___ge__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
6303  }
6304  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
6305  result = (bool)((libbgp::Prefix4 const *)arg1)->operator >=((libbgp::Prefix const &)*arg2);
6306  resultobj = SWIG_From_bool(static_cast< bool >(result));
6307  return resultobj;
6308 fail:
6309  return NULL;
6310 }
6311 
6312 
6313 SWIGINTERN PyObject *_wrap_Prefix4___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6314  PyObject *resultobj = 0;
6315  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
6316  libbgp::Prefix *arg2 = 0 ;
6317  void *argp1 = 0 ;
6318  int res1 = 0 ;
6319  void *argp2 = 0 ;
6320  int res2 = 0 ;
6321  PyObject * obj0 = 0 ;
6322  PyObject * obj1 = 0 ;
6323  bool result;
6324 
6325  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix4___le__",&obj0,&obj1)) SWIG_fail;
6326  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
6327  if (!SWIG_IsOK(res1)) {
6328  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4___le__" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
6329  }
6330  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6331  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
6332  if (!SWIG_IsOK(res2)) {
6333  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix4___le__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
6334  }
6335  if (!argp2) {
6336  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix4___le__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
6337  }
6338  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
6339  result = (bool)((libbgp::Prefix4 const *)arg1)->operator <=((libbgp::Prefix const &)*arg2);
6340  resultobj = SWIG_From_bool(static_cast< bool >(result));
6341  return resultobj;
6342 fail:
6343  return NULL;
6344 }
6345 
6346 
6347 SWIGINTERN PyObject *_wrap_Prefix4___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6348  PyObject *resultobj = 0;
6349  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
6350  libbgp::Prefix *arg2 = 0 ;
6351  void *argp1 = 0 ;
6352  int res1 = 0 ;
6353  void *argp2 = 0 ;
6354  int res2 = 0 ;
6355  PyObject * obj0 = 0 ;
6356  PyObject * obj1 = 0 ;
6357  bool result;
6358 
6359  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix4___ne__",&obj0,&obj1)) SWIG_fail;
6360  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
6361  if (!SWIG_IsOK(res1)) {
6362  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4___ne__" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
6363  }
6364  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6365  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
6366  if (!SWIG_IsOK(res2)) {
6367  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix4___ne__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
6368  }
6369  if (!argp2) {
6370  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix4___ne__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
6371  }
6372  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
6373  result = (bool)((libbgp::Prefix4 const *)arg1)->operator !=((libbgp::Prefix const &)*arg2);
6374  resultobj = SWIG_From_bool(static_cast< bool >(result));
6375  return resultobj;
6376 fail:
6377  return NULL;
6378 }
6379 
6380 
6381 SWIGINTERN PyObject *_wrap_Prefix4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6382  PyObject *resultobj = 0;
6383  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
6384  uint32_t arg2 ;
6385  uint8_t arg3 ;
6386  void *argp1 = 0 ;
6387  int res1 = 0 ;
6388  unsigned int val2 ;
6389  int ecode2 = 0 ;
6390  unsigned char val3 ;
6391  int ecode3 = 0 ;
6392  PyObject * obj0 = 0 ;
6393  PyObject * obj1 = 0 ;
6394  PyObject * obj2 = 0 ;
6395  bool result;
6396 
6397  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix4_set",&obj0,&obj1,&obj2)) SWIG_fail;
6398  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
6399  if (!SWIG_IsOK(res1)) {
6400  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4_set" "', argument " "1"" of type '" "libbgp::Prefix4 *""'");
6401  }
6402  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6403  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6404  if (!SWIG_IsOK(ecode2)) {
6405  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Prefix4_set" "', argument " "2"" of type '" "uint32_t""'");
6406  }
6407  arg2 = static_cast< uint32_t >(val2);
6408  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
6409  if (!SWIG_IsOK(ecode3)) {
6410  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Prefix4_set" "', argument " "3"" of type '" "uint8_t""'");
6411  }
6412  arg3 = static_cast< uint8_t >(val3);
6413  result = (bool)(arg1)->set(arg2,arg3);
6414  resultobj = SWIG_From_bool(static_cast< bool >(result));
6415  return resultobj;
6416 fail:
6417  return NULL;
6418 }
6419 
6420 
6421 SWIGINTERN PyObject *_wrap_Prefix4_setPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6422  PyObject *resultobj = 0;
6423  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
6424  uint32_t arg2 ;
6425  void *argp1 = 0 ;
6426  int res1 = 0 ;
6427  unsigned int val2 ;
6428  int ecode2 = 0 ;
6429  PyObject * obj0 = 0 ;
6430  PyObject * obj1 = 0 ;
6431  bool result;
6432 
6433  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix4_setPrefix",&obj0,&obj1)) SWIG_fail;
6434  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
6435  if (!SWIG_IsOK(res1)) {
6436  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4_setPrefix" "', argument " "1"" of type '" "libbgp::Prefix4 *""'");
6437  }
6438  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6439  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6440  if (!SWIG_IsOK(ecode2)) {
6441  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Prefix4_setPrefix" "', argument " "2"" of type '" "uint32_t""'");
6442  }
6443  arg2 = static_cast< uint32_t >(val2);
6444  result = (bool)(arg1)->setPrefix(arg2);
6445  resultobj = SWIG_From_bool(static_cast< bool >(result));
6446  return resultobj;
6447 fail:
6448  return NULL;
6449 }
6450 
6451 
6452 SWIGINTERN PyObject *_wrap_Prefix4_setLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6453  PyObject *resultobj = 0;
6454  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
6455  uint8_t arg2 ;
6456  void *argp1 = 0 ;
6457  int res1 = 0 ;
6458  unsigned char val2 ;
6459  int ecode2 = 0 ;
6460  PyObject * obj0 = 0 ;
6461  PyObject * obj1 = 0 ;
6462  bool result;
6463 
6464  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix4_setLength",&obj0,&obj1)) SWIG_fail;
6465  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
6466  if (!SWIG_IsOK(res1)) {
6467  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4_setLength" "', argument " "1"" of type '" "libbgp::Prefix4 *""'");
6468  }
6469  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6470  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
6471  if (!SWIG_IsOK(ecode2)) {
6472  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Prefix4_setLength" "', argument " "2"" of type '" "uint8_t""'");
6473  }
6474  arg2 = static_cast< uint8_t >(val2);
6475  result = (bool)(arg1)->setLength(arg2);
6476  resultobj = SWIG_From_bool(static_cast< bool >(result));
6477  return resultobj;
6478 fail:
6479  return NULL;
6480 }
6481 
6482 
6483 SWIGINTERN PyObject *_wrap_Prefix4_getPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6484  PyObject *resultobj = 0;
6485  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
6486  void *argp1 = 0 ;
6487  int res1 = 0 ;
6488  PyObject * obj0 = 0 ;
6489  uint32_t result;
6490 
6491  if (!PyArg_ParseTuple(args,(char *)"O:Prefix4_getPrefix",&obj0)) SWIG_fail;
6492  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
6493  if (!SWIG_IsOK(res1)) {
6494  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4_getPrefix" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
6495  }
6496  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6497  result = (uint32_t)((libbgp::Prefix4 const *)arg1)->getPrefix();
6498  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
6499  return resultobj;
6500 fail:
6501  return NULL;
6502 }
6503 
6504 
6505 SWIGINTERN PyObject *_wrap_Prefix4_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6506  PyObject *resultobj = 0;
6507  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
6508  void *argp1 = 0 ;
6509  int res1 = 0 ;
6510  PyObject * obj0 = 0 ;
6511  uint8_t result;
6512 
6513  if (!PyArg_ParseTuple(args,(char *)"O:Prefix4_getLength",&obj0)) SWIG_fail;
6514  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
6515  if (!SWIG_IsOK(res1)) {
6516  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4_getLength" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
6517  }
6518  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6519  result = (uint8_t)((libbgp::Prefix4 const *)arg1)->getLength();
6520  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
6521  return resultobj;
6522 fail:
6523  return NULL;
6524 }
6525 
6526 
6527 SWIGINTERN PyObject *_wrap_Prefix4_getMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6528  PyObject *resultobj = 0;
6529  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
6530  void *argp1 = 0 ;
6531  int res1 = 0 ;
6532  PyObject * obj0 = 0 ;
6533  uint32_t result;
6534 
6535  if (!PyArg_ParseTuple(args,(char *)"O:Prefix4_getMask",&obj0)) SWIG_fail;
6536  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
6537  if (!SWIG_IsOK(res1)) {
6538  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4_getMask" "', argument " "1"" of type '" "libbgp::Prefix4 const *""'");
6539  }
6540  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6541  result = (uint32_t)((libbgp::Prefix4 const *)arg1)->getMask();
6542  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
6543  return resultobj;
6544 fail:
6545  return NULL;
6546 }
6547 
6548 
6549 SWIGINTERN PyObject *_wrap_delete_Prefix4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6550  PyObject *resultobj = 0;
6551  libbgp::Prefix4 *arg1 = (libbgp::Prefix4 *) 0 ;
6552  void *argp1 = 0 ;
6553  int res1 = 0 ;
6554  PyObject * obj0 = 0 ;
6555 
6556  if (!PyArg_ParseTuple(args,(char *)"O:delete_Prefix4",&obj0)) SWIG_fail;
6557  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix4, SWIG_POINTER_DISOWN | 0 );
6558  if (!SWIG_IsOK(res1)) {
6559  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Prefix4" "', argument " "1"" of type '" "libbgp::Prefix4 *""'");
6560  }
6561  arg1 = reinterpret_cast< libbgp::Prefix4 * >(argp1);
6562  delete arg1;
6563  resultobj = SWIG_Py_Void();
6564  return resultobj;
6565 fail:
6566  return NULL;
6567 }
6568 
6569 
6570 SWIGINTERN PyObject *Prefix4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6571  PyObject *obj;
6572  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
6573  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__Prefix4, SWIG_NewClientData(obj));
6574  return SWIG_Py_Void();
6575 }
6576 
6577 SWIGINTERN PyObject *_wrap_cidr_to_mask6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6578  PyObject *resultobj = 0;
6579  uint8_t arg1 ;
6580  uint8_t *arg2 ;
6581  unsigned char val1 ;
6582  int ecode1 = 0 ;
6583  void *argp2 = 0 ;
6584  int res2 = 0 ;
6585  PyObject * obj0 = 0 ;
6586  PyObject * obj1 = 0 ;
6587  bool result;
6588 
6589  if (!PyArg_ParseTuple(args,(char *)"OO:cidr_to_mask6",&obj0,&obj1)) SWIG_fail;
6590  ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
6591  if (!SWIG_IsOK(ecode1)) {
6592  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cidr_to_mask6" "', argument " "1"" of type '" "uint8_t""'");
6593  }
6594  arg1 = static_cast< uint8_t >(val1);
6595  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
6596  if (!SWIG_IsOK(res2)) {
6597  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cidr_to_mask6" "', argument " "2"" of type '" "uint8_t [16]""'");
6598  }
6599  arg2 = reinterpret_cast< uint8_t * >(argp2);
6600  result = (bool)libbgp::cidr_to_mask6(arg1,arg2);
6601  resultobj = SWIG_From_bool(static_cast< bool >(result));
6602  return resultobj;
6603 fail:
6604  return NULL;
6605 }
6606 
6607 
6608 SWIGINTERN PyObject *_wrap_mask_ipv6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6609  PyObject *resultobj = 0;
6610  uint8_t *arg1 ;
6611  uint8_t arg2 ;
6612  uint8_t *arg3 ;
6613  void *argp1 = 0 ;
6614  int res1 = 0 ;
6615  unsigned char val2 ;
6616  int ecode2 = 0 ;
6617  void *argp3 = 0 ;
6618  int res3 = 0 ;
6619  PyObject * obj0 = 0 ;
6620  PyObject * obj1 = 0 ;
6621  PyObject * obj2 = 0 ;
6622  bool result;
6623 
6624  if (!PyArg_ParseTuple(args,(char *)"OOO:mask_ipv6",&obj0,&obj1,&obj2)) SWIG_fail;
6625  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 | 0 );
6626  if (!SWIG_IsOK(res1)) {
6627  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mask_ipv6" "', argument " "1"" of type '" "uint8_t const [16]""'");
6628  }
6629  arg1 = reinterpret_cast< uint8_t * >(argp1);
6630  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
6631  if (!SWIG_IsOK(ecode2)) {
6632  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mask_ipv6" "', argument " "2"" of type '" "uint8_t""'");
6633  }
6634  arg2 = static_cast< uint8_t >(val2);
6635  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 );
6636  if (!SWIG_IsOK(res3)) {
6637  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mask_ipv6" "', argument " "3"" of type '" "uint8_t [16]""'");
6638  }
6639  arg3 = reinterpret_cast< uint8_t * >(argp3);
6640  result = (bool)libbgp::mask_ipv6((unsigned char const (*))arg1,arg2,arg3);
6641  resultobj = SWIG_From_bool(static_cast< bool >(result));
6642  return resultobj;
6643 fail:
6644  return NULL;
6645 }
6646 
6647 
6648 SWIGINTERN PyObject *_wrap_v6addr_is_zero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6649  PyObject *resultobj = 0;
6650  uint8_t *arg1 ;
6651  void *argp1 = 0 ;
6652  int res1 = 0 ;
6653  PyObject * obj0 = 0 ;
6654  bool result;
6655 
6656  if (!PyArg_ParseTuple(args,(char *)"O:v6addr_is_zero",&obj0)) SWIG_fail;
6657  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 | 0 );
6658  if (!SWIG_IsOK(res1)) {
6659  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "v6addr_is_zero" "', argument " "1"" of type '" "uint8_t const [16]""'");
6660  }
6661  arg1 = reinterpret_cast< uint8_t * >(argp1);
6662  result = (bool)libbgp::v6addr_is_zero((unsigned char const (*))arg1);
6663  resultobj = SWIG_From_bool(static_cast< bool >(result));
6664  return resultobj;
6665 fail:
6666  return NULL;
6667 }
6668 
6669 
6670 SWIGINTERN PyObject *_wrap_new_Prefix6__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6671  PyObject *resultobj = 0;
6672  libbgp::Prefix6 *result = 0 ;
6673 
6674  if (!PyArg_ParseTuple(args,(char *)":new_Prefix6")) SWIG_fail;
6675  result = (libbgp::Prefix6 *)new libbgp::Prefix6();
6676  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Prefix6, SWIG_POINTER_NEW | 0 );
6677  return resultobj;
6678 fail:
6679  return NULL;
6680 }
6681 
6682 
6683 SWIGINTERN PyObject *_wrap_new_Prefix6__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6684  PyObject *resultobj = 0;
6685  uint8_t *arg1 ;
6686  uint8_t arg2 ;
6687  void *argp1 = 0 ;
6688  int res1 = 0 ;
6689  unsigned char val2 ;
6690  int ecode2 = 0 ;
6691  PyObject * obj0 = 0 ;
6692  PyObject * obj1 = 0 ;
6693  libbgp::Prefix6 *result = 0 ;
6694 
6695  if (!PyArg_ParseTuple(args,(char *)"OO:new_Prefix6",&obj0,&obj1)) SWIG_fail;
6696  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 | 0 );
6697  if (!SWIG_IsOK(res1)) {
6698  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Prefix6" "', argument " "1"" of type '" "uint8_t const [16]""'");
6699  }
6700  arg1 = reinterpret_cast< uint8_t * >(argp1);
6701  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
6702  if (!SWIG_IsOK(ecode2)) {
6703  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Prefix6" "', argument " "2"" of type '" "uint8_t""'");
6704  }
6705  arg2 = static_cast< uint8_t >(val2);
6706  result = (libbgp::Prefix6 *)new libbgp::Prefix6((uint8_t const (*))arg1,arg2);
6707  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Prefix6, SWIG_POINTER_NEW | 0 );
6708  return resultobj;
6709 fail:
6710  return NULL;
6711 }
6712 
6713 
6714 SWIGINTERN PyObject *_wrap_new_Prefix6__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6715  PyObject *resultobj = 0;
6716  char *arg1 = (char *) 0 ;
6717  uint8_t arg2 ;
6718  int res1 ;
6719  char *buf1 = 0 ;
6720  int alloc1 = 0 ;
6721  unsigned char val2 ;
6722  int ecode2 = 0 ;
6723  PyObject * obj0 = 0 ;
6724  PyObject * obj1 = 0 ;
6725  libbgp::Prefix6 *result = 0 ;
6726 
6727  if (!PyArg_ParseTuple(args,(char *)"OO:new_Prefix6",&obj0,&obj1)) SWIG_fail;
6728  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
6729  if (!SWIG_IsOK(res1)) {
6730  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Prefix6" "', argument " "1"" of type '" "char const *""'");
6731  }
6732  arg1 = reinterpret_cast< char * >(buf1);
6733  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
6734  if (!SWIG_IsOK(ecode2)) {
6735  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Prefix6" "', argument " "2"" of type '" "uint8_t""'");
6736  }
6737  arg2 = static_cast< uint8_t >(val2);
6738  result = (libbgp::Prefix6 *)new libbgp::Prefix6((char const *)arg1,arg2);
6739  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Prefix6, SWIG_POINTER_NEW | 0 );
6740  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
6741  return resultobj;
6742 fail:
6743  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
6744  return NULL;
6745 }
6746 
6747 
6748 SWIGINTERN PyObject *_wrap_new_Prefix6(PyObject *self, PyObject *args) {
6749  Py_ssize_t argc;
6750  PyObject *argv[3] = {
6751  0
6752  };
6753  Py_ssize_t ii;
6754 
6755  if (!PyTuple_Check(args)) SWIG_fail;
6756  argc = args ? PyObject_Length(args) : 0;
6757  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
6758  argv[ii] = PyTuple_GET_ITEM(args,ii);
6759  }
6760  if (argc == 0) {
6761  return _wrap_new_Prefix6__SWIG_0(self, args);
6762  }
6763  if (argc == 2) {
6764  int _v;
6765  void *vptr = 0;
6766  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
6767  _v = SWIG_CheckState(res);
6768  if (_v) {
6769  {
6770  int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
6771  _v = SWIG_CheckState(res);
6772  }
6773  if (_v) {
6774  return _wrap_new_Prefix6__SWIG_1(self, args);
6775  }
6776  }
6777  }
6778  if (argc == 2) {
6779  int _v;
6780  int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
6781  _v = SWIG_CheckState(res);
6782  if (_v) {
6783  {
6784  int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
6785  _v = SWIG_CheckState(res);
6786  }
6787  if (_v) {
6788  return _wrap_new_Prefix6__SWIG_2(self, args);
6789  }
6790  }
6791  }
6792 
6793 fail:
6794  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Prefix6'.\n"
6795  " Possible C/C++ prototypes are:\n"
6796  " libbgp::Prefix6::Prefix6()\n"
6797  " libbgp::Prefix6::Prefix6(uint8_t const [16],uint8_t)\n"
6798  " libbgp::Prefix6::Prefix6(char const *,uint8_t)\n");
6799  return 0;
6800 }
6801 
6802 
6803 SWIGINTERN PyObject *_wrap_Prefix6_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6804  PyObject *resultobj = 0;
6805  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
6806  uint8_t *arg2 = (uint8_t *) 0 ;
6807  size_t arg3 ;
6808  void *argp1 = 0 ;
6809  int res1 = 0 ;
6810  void *argp2 = 0 ;
6811  int res2 = 0 ;
6812  size_t val3 ;
6813  int ecode3 = 0 ;
6814  PyObject * obj0 = 0 ;
6815  PyObject * obj1 = 0 ;
6816  PyObject * obj2 = 0 ;
6817  ssize_t result;
6818 
6819  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix6_parse",&obj0,&obj1,&obj2)) SWIG_fail;
6820  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
6821  if (!SWIG_IsOK(res1)) {
6822  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_parse" "', argument " "1"" of type '" "libbgp::Prefix6 *""'");
6823  }
6824  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
6825  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
6826  if (!SWIG_IsOK(res2)) {
6827  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6_parse" "', argument " "2"" of type '" "uint8_t const *""'");
6828  }
6829  arg2 = reinterpret_cast< uint8_t * >(argp2);
6830  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
6831  if (!SWIG_IsOK(ecode3)) {
6832  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Prefix6_parse" "', argument " "3"" of type '" "size_t""'");
6833  }
6834  arg3 = static_cast< size_t >(val3);
6835  result = (arg1)->parse((uint8_t const *)arg2,arg3);
6836  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
6837  return resultobj;
6838 fail:
6839  return NULL;
6840 }
6841 
6842 
6843 SWIGINTERN PyObject *_wrap_Prefix6_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6844  PyObject *resultobj = 0;
6845  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
6846  uint8_t *arg2 = (uint8_t *) 0 ;
6847  size_t arg3 ;
6848  void *argp1 = 0 ;
6849  int res1 = 0 ;
6850  void *argp2 = 0 ;
6851  int res2 = 0 ;
6852  size_t val3 ;
6853  int ecode3 = 0 ;
6854  PyObject * obj0 = 0 ;
6855  PyObject * obj1 = 0 ;
6856  PyObject * obj2 = 0 ;
6857  ssize_t result;
6858 
6859  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix6_write",&obj0,&obj1,&obj2)) SWIG_fail;
6860  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
6861  if (!SWIG_IsOK(res1)) {
6862  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_write" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
6863  }
6864  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
6865  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
6866  if (!SWIG_IsOK(res2)) {
6867  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6_write" "', argument " "2"" of type '" "uint8_t *""'");
6868  }
6869  arg2 = reinterpret_cast< uint8_t * >(argp2);
6870  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
6871  if (!SWIG_IsOK(ecode3)) {
6872  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Prefix6_write" "', argument " "3"" of type '" "size_t""'");
6873  }
6874  arg3 = static_cast< size_t >(val3);
6875  result = ((libbgp::Prefix6 const *)arg1)->write(arg2,arg3);
6876  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
6877  return resultobj;
6878 fail:
6879  return NULL;
6880 }
6881 
6882 
6883 SWIGINTERN PyObject *_wrap_Prefix6_Includes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6884  PyObject *resultobj = 0;
6885  uint8_t *arg1 ;
6886  uint8_t arg2 ;
6887  uint8_t *arg3 ;
6888  void *argp1 = 0 ;
6889  int res1 = 0 ;
6890  unsigned char val2 ;
6891  int ecode2 = 0 ;
6892  void *argp3 = 0 ;
6893  int res3 = 0 ;
6894  PyObject * obj0 = 0 ;
6895  PyObject * obj1 = 0 ;
6896  PyObject * obj2 = 0 ;
6897  bool result;
6898 
6899  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix6_Includes",&obj0,&obj1,&obj2)) SWIG_fail;
6900  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 | 0 );
6901  if (!SWIG_IsOK(res1)) {
6902  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_Includes" "', argument " "1"" of type '" "uint8_t const [16]""'");
6903  }
6904  arg1 = reinterpret_cast< uint8_t * >(argp1);
6905  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
6906  if (!SWIG_IsOK(ecode2)) {
6907  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Prefix6_Includes" "', argument " "2"" of type '" "uint8_t""'");
6908  }
6909  arg2 = static_cast< uint8_t >(val2);
6910  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 );
6911  if (!SWIG_IsOK(res3)) {
6912  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Prefix6_Includes" "', argument " "3"" of type '" "uint8_t const [16]""'");
6913  }
6914  arg3 = reinterpret_cast< uint8_t * >(argp3);
6915  result = (bool)libbgp::Prefix6::Includes((unsigned char const (*))arg1,arg2,(unsigned char const (*))arg3);
6916  resultobj = SWIG_From_bool(static_cast< bool >(result));
6917  return resultobj;
6918 fail:
6919  return NULL;
6920 }
6921 
6922 
6923 SWIGINTERN PyObject *_wrap_Prefix6_Includes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6924  PyObject *resultobj = 0;
6925  uint8_t *arg1 ;
6926  uint8_t arg2 ;
6927  uint8_t *arg3 ;
6928  uint8_t arg4 ;
6929  void *argp1 = 0 ;
6930  int res1 = 0 ;
6931  unsigned char val2 ;
6932  int ecode2 = 0 ;
6933  void *argp3 = 0 ;
6934  int res3 = 0 ;
6935  unsigned char val4 ;
6936  int ecode4 = 0 ;
6937  PyObject * obj0 = 0 ;
6938  PyObject * obj1 = 0 ;
6939  PyObject * obj2 = 0 ;
6940  PyObject * obj3 = 0 ;
6941  bool result;
6942 
6943  if (!PyArg_ParseTuple(args,(char *)"OOOO:Prefix6_Includes",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6944  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 | 0 );
6945  if (!SWIG_IsOK(res1)) {
6946  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_Includes" "', argument " "1"" of type '" "uint8_t const [16]""'");
6947  }
6948  arg1 = reinterpret_cast< uint8_t * >(argp1);
6949  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
6950  if (!SWIG_IsOK(ecode2)) {
6951  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Prefix6_Includes" "', argument " "2"" of type '" "uint8_t""'");
6952  }
6953  arg2 = static_cast< uint8_t >(val2);
6954  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 );
6955  if (!SWIG_IsOK(res3)) {
6956  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Prefix6_Includes" "', argument " "3"" of type '" "uint8_t const [16]""'");
6957  }
6958  arg3 = reinterpret_cast< uint8_t * >(argp3);
6959  ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
6960  if (!SWIG_IsOK(ecode4)) {
6961  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Prefix6_Includes" "', argument " "4"" of type '" "uint8_t""'");
6962  }
6963  arg4 = static_cast< uint8_t >(val4);
6964  result = (bool)libbgp::Prefix6::Includes((unsigned char const (*))arg1,arg2,(unsigned char const (*))arg3,arg4);
6965  resultobj = SWIG_From_bool(static_cast< bool >(result));
6966  return resultobj;
6967 fail:
6968  return NULL;
6969 }
6970 
6971 
6972 SWIGINTERN PyObject *_wrap_Prefix6_Includes(PyObject *self, PyObject *args) {
6973  Py_ssize_t argc;
6974  PyObject *argv[5] = {
6975  0
6976  };
6977  Py_ssize_t ii;
6978 
6979  if (!PyTuple_Check(args)) SWIG_fail;
6980  argc = args ? PyObject_Length(args) : 0;
6981  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
6982  argv[ii] = PyTuple_GET_ITEM(args,ii);
6983  }
6984  if (argc == 3) {
6985  int _v;
6986  void *vptr = 0;
6987  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
6988  _v = SWIG_CheckState(res);
6989  if (_v) {
6990  {
6991  int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
6992  _v = SWIG_CheckState(res);
6993  }
6994  if (_v) {
6995  void *vptr = 0;
6996  int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0);
6997  _v = SWIG_CheckState(res);
6998  if (_v) {
6999  return _wrap_Prefix6_Includes__SWIG_0(self, args);
7000  }
7001  }
7002  }
7003  }
7004  if (argc == 4) {
7005  int _v;
7006  void *vptr = 0;
7007  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
7008  _v = SWIG_CheckState(res);
7009  if (_v) {
7010  {
7011  int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
7012  _v = SWIG_CheckState(res);
7013  }
7014  if (_v) {
7015  void *vptr = 0;
7016  int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0);
7017  _v = SWIG_CheckState(res);
7018  if (_v) {
7019  {
7020  int res = SWIG_AsVal_unsigned_SS_char(argv[3], NULL);
7021  _v = SWIG_CheckState(res);
7022  }
7023  if (_v) {
7024  return _wrap_Prefix6_Includes__SWIG_1(self, args);
7025  }
7026  }
7027  }
7028  }
7029  }
7030 
7031 fail:
7032  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Prefix6_Includes'.\n"
7033  " Possible C/C++ prototypes are:\n"
7034  " libbgp::Prefix6::Includes(uint8_t const [16],uint8_t,uint8_t const [16])\n"
7035  " libbgp::Prefix6::Includes(uint8_t const [16],uint8_t,uint8_t const [16],uint8_t)\n");
7036  return 0;
7037 }
7038 
7039 
7040 SWIGINTERN PyObject *_wrap_Prefix6_includes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7041  PyObject *resultobj = 0;
7042  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7043  uint8_t *arg2 ;
7044  void *argp1 = 0 ;
7045  int res1 = 0 ;
7046  void *argp2 = 0 ;
7047  int res2 = 0 ;
7048  PyObject * obj0 = 0 ;
7049  PyObject * obj1 = 0 ;
7050  bool result;
7051 
7052  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix6_includes",&obj0,&obj1)) SWIG_fail;
7053  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7054  if (!SWIG_IsOK(res1)) {
7055  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_includes" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
7056  }
7057  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7058  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
7059  if (!SWIG_IsOK(res2)) {
7060  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6_includes" "', argument " "2"" of type '" "uint8_t const [16]""'");
7061  }
7062  arg2 = reinterpret_cast< uint8_t * >(argp2);
7063  result = (bool)((libbgp::Prefix6 const *)arg1)->includes((uint8_t const (*))arg2);
7064  resultobj = SWIG_From_bool(static_cast< bool >(result));
7065  return resultobj;
7066 fail:
7067  return NULL;
7068 }
7069 
7070 
7071 SWIGINTERN PyObject *_wrap_Prefix6_includes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7072  PyObject *resultobj = 0;
7073  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7074  char *arg2 = (char *) 0 ;
7075  void *argp1 = 0 ;
7076  int res1 = 0 ;
7077  int res2 ;
7078  char *buf2 = 0 ;
7079  int alloc2 = 0 ;
7080  PyObject * obj0 = 0 ;
7081  PyObject * obj1 = 0 ;
7082  bool result;
7083 
7084  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix6_includes",&obj0,&obj1)) SWIG_fail;
7085  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7086  if (!SWIG_IsOK(res1)) {
7087  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_includes" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
7088  }
7089  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7090  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7091  if (!SWIG_IsOK(res2)) {
7092  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6_includes" "', argument " "2"" of type '" "char const *""'");
7093  }
7094  arg2 = reinterpret_cast< char * >(buf2);
7095  result = (bool)((libbgp::Prefix6 const *)arg1)->includes((char const *)arg2);
7096  resultobj = SWIG_From_bool(static_cast< bool >(result));
7097  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7098  return resultobj;
7099 fail:
7100  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7101  return NULL;
7102 }
7103 
7104 
7105 SWIGINTERN PyObject *_wrap_Prefix6_includes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7106  PyObject *resultobj = 0;
7107  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7108  libbgp::Prefix *arg2 = 0 ;
7109  void *argp1 = 0 ;
7110  int res1 = 0 ;
7111  void *argp2 = 0 ;
7112  int res2 = 0 ;
7113  PyObject * obj0 = 0 ;
7114  PyObject * obj1 = 0 ;
7115  bool result;
7116 
7117  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix6_includes",&obj0,&obj1)) SWIG_fail;
7118  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7119  if (!SWIG_IsOK(res1)) {
7120  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_includes" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
7121  }
7122  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7123  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
7124  if (!SWIG_IsOK(res2)) {
7125  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6_includes" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
7126  }
7127  if (!argp2) {
7128  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix6_includes" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
7129  }
7130  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
7131  result = (bool)((libbgp::Prefix6 const *)arg1)->includes((libbgp::Prefix const &)*arg2);
7132  resultobj = SWIG_From_bool(static_cast< bool >(result));
7133  return resultobj;
7134 fail:
7135  return NULL;
7136 }
7137 
7138 
7139 SWIGINTERN PyObject *_wrap_Prefix6_includes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7140  PyObject *resultobj = 0;
7141  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7142  uint8_t *arg2 ;
7143  uint8_t arg3 ;
7144  void *argp1 = 0 ;
7145  int res1 = 0 ;
7146  void *argp2 = 0 ;
7147  int res2 = 0 ;
7148  unsigned char val3 ;
7149  int ecode3 = 0 ;
7150  PyObject * obj0 = 0 ;
7151  PyObject * obj1 = 0 ;
7152  PyObject * obj2 = 0 ;
7153  bool result;
7154 
7155  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix6_includes",&obj0,&obj1,&obj2)) SWIG_fail;
7156  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7157  if (!SWIG_IsOK(res1)) {
7158  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_includes" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
7159  }
7160  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7161  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
7162  if (!SWIG_IsOK(res2)) {
7163  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6_includes" "', argument " "2"" of type '" "uint8_t const [16]""'");
7164  }
7165  arg2 = reinterpret_cast< uint8_t * >(argp2);
7166  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
7167  if (!SWIG_IsOK(ecode3)) {
7168  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Prefix6_includes" "', argument " "3"" of type '" "uint8_t""'");
7169  }
7170  arg3 = static_cast< uint8_t >(val3);
7171  result = (bool)((libbgp::Prefix6 const *)arg1)->includes((uint8_t const (*))arg2,arg3);
7172  resultobj = SWIG_From_bool(static_cast< bool >(result));
7173  return resultobj;
7174 fail:
7175  return NULL;
7176 }
7177 
7178 
7179 SWIGINTERN PyObject *_wrap_Prefix6_includes__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7180  PyObject *resultobj = 0;
7181  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7182  char *arg2 = (char *) 0 ;
7183  uint8_t arg3 ;
7184  void *argp1 = 0 ;
7185  int res1 = 0 ;
7186  int res2 ;
7187  char *buf2 = 0 ;
7188  int alloc2 = 0 ;
7189  unsigned char val3 ;
7190  int ecode3 = 0 ;
7191  PyObject * obj0 = 0 ;
7192  PyObject * obj1 = 0 ;
7193  PyObject * obj2 = 0 ;
7194  bool result;
7195 
7196  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix6_includes",&obj0,&obj1,&obj2)) SWIG_fail;
7197  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7198  if (!SWIG_IsOK(res1)) {
7199  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_includes" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
7200  }
7201  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7202  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7203  if (!SWIG_IsOK(res2)) {
7204  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6_includes" "', argument " "2"" of type '" "char const *""'");
7205  }
7206  arg2 = reinterpret_cast< char * >(buf2);
7207  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
7208  if (!SWIG_IsOK(ecode3)) {
7209  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Prefix6_includes" "', argument " "3"" of type '" "uint8_t""'");
7210  }
7211  arg3 = static_cast< uint8_t >(val3);
7212  result = (bool)((libbgp::Prefix6 const *)arg1)->includes((char const *)arg2,arg3);
7213  resultobj = SWIG_From_bool(static_cast< bool >(result));
7214  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7215  return resultobj;
7216 fail:
7217  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
7218  return NULL;
7219 }
7220 
7221 
7222 SWIGINTERN PyObject *_wrap_Prefix6_includes(PyObject *self, PyObject *args) {
7223  Py_ssize_t argc;
7224  PyObject *argv[4] = {
7225  0
7226  };
7227  Py_ssize_t ii;
7228 
7229  if (!PyTuple_Check(args)) SWIG_fail;
7230  argc = args ? PyObject_Length(args) : 0;
7231  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
7232  argv[ii] = PyTuple_GET_ITEM(args,ii);
7233  }
7234  if (argc == 2) {
7235  int _v;
7236  void *vptr = 0;
7237  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__Prefix6, 0);
7238  _v = SWIG_CheckState(res);
7239  if (_v) {
7240  void *vptr = 0;
7241  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
7242  _v = SWIG_CheckState(res);
7243  if (_v) {
7244  return _wrap_Prefix6_includes__SWIG_0(self, args);
7245  }
7246  }
7247  }
7248  if (argc == 2) {
7249  int _v;
7250  void *vptr = 0;
7251  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__Prefix6, 0);
7252  _v = SWIG_CheckState(res);
7253  if (_v) {
7254  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_libbgp__Prefix, 0);
7255  _v = SWIG_CheckState(res);
7256  if (_v) {
7257  return _wrap_Prefix6_includes__SWIG_2(self, args);
7258  }
7259  }
7260  }
7261  if (argc == 2) {
7262  int _v;
7263  void *vptr = 0;
7264  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__Prefix6, 0);
7265  _v = SWIG_CheckState(res);
7266  if (_v) {
7267  int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
7268  _v = SWIG_CheckState(res);
7269  if (_v) {
7270  return _wrap_Prefix6_includes__SWIG_1(self, args);
7271  }
7272  }
7273  }
7274  if (argc == 3) {
7275  int _v;
7276  void *vptr = 0;
7277  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__Prefix6, 0);
7278  _v = SWIG_CheckState(res);
7279  if (_v) {
7280  void *vptr = 0;
7281  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
7282  _v = SWIG_CheckState(res);
7283  if (_v) {
7284  {
7285  int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
7286  _v = SWIG_CheckState(res);
7287  }
7288  if (_v) {
7289  return _wrap_Prefix6_includes__SWIG_3(self, args);
7290  }
7291  }
7292  }
7293  }
7294  if (argc == 3) {
7295  int _v;
7296  void *vptr = 0;
7297  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__Prefix6, 0);
7298  _v = SWIG_CheckState(res);
7299  if (_v) {
7300  int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
7301  _v = SWIG_CheckState(res);
7302  if (_v) {
7303  {
7304  int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
7305  _v = SWIG_CheckState(res);
7306  }
7307  if (_v) {
7308  return _wrap_Prefix6_includes__SWIG_4(self, args);
7309  }
7310  }
7311  }
7312  }
7313 
7314 fail:
7315  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'Prefix6_includes'.\n"
7316  " Possible C/C++ prototypes are:\n"
7317  " libbgp::Prefix6::includes(uint8_t const [16]) const\n"
7318  " libbgp::Prefix6::includes(char const *) const\n"
7319  " libbgp::Prefix6::includes(libbgp::Prefix const &) const\n"
7320  " libbgp::Prefix6::includes(uint8_t const [16],uint8_t) const\n"
7321  " libbgp::Prefix6::includes(char const *,uint8_t) const\n");
7322  return 0;
7323 }
7324 
7325 
7326 SWIGINTERN PyObject *_wrap_Prefix6___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7327  PyObject *resultobj = 0;
7328  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7329  libbgp::Prefix *arg2 = 0 ;
7330  void *argp1 = 0 ;
7331  int res1 = 0 ;
7332  void *argp2 = 0 ;
7333  int res2 = 0 ;
7334  PyObject * obj0 = 0 ;
7335  PyObject * obj1 = 0 ;
7336  bool result;
7337 
7338  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix6___eq__",&obj0,&obj1)) SWIG_fail;
7339  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7340  if (!SWIG_IsOK(res1)) {
7341  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6___eq__" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
7342  }
7343  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7344  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
7345  if (!SWIG_IsOK(res2)) {
7346  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6___eq__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
7347  }
7348  if (!argp2) {
7349  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix6___eq__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
7350  }
7351  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
7352  result = (bool)((libbgp::Prefix6 const *)arg1)->operator ==((libbgp::Prefix const &)*arg2);
7353  resultobj = SWIG_From_bool(static_cast< bool >(result));
7354  return resultobj;
7355 fail:
7356  return NULL;
7357 }
7358 
7359 
7360 SWIGINTERN PyObject *_wrap_Prefix6___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7361  PyObject *resultobj = 0;
7362  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7363  libbgp::Prefix *arg2 = 0 ;
7364  void *argp1 = 0 ;
7365  int res1 = 0 ;
7366  void *argp2 = 0 ;
7367  int res2 = 0 ;
7368  PyObject * obj0 = 0 ;
7369  PyObject * obj1 = 0 ;
7370  bool result;
7371 
7372  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix6___gt__",&obj0,&obj1)) SWIG_fail;
7373  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7374  if (!SWIG_IsOK(res1)) {
7375  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6___gt__" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
7376  }
7377  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7378  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
7379  if (!SWIG_IsOK(res2)) {
7380  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6___gt__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
7381  }
7382  if (!argp2) {
7383  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix6___gt__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
7384  }
7385  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
7386  result = (bool)((libbgp::Prefix6 const *)arg1)->operator >((libbgp::Prefix const &)*arg2);
7387  resultobj = SWIG_From_bool(static_cast< bool >(result));
7388  return resultobj;
7389 fail:
7390  return NULL;
7391 }
7392 
7393 
7394 SWIGINTERN PyObject *_wrap_Prefix6___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7395  PyObject *resultobj = 0;
7396  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7397  libbgp::Prefix *arg2 = 0 ;
7398  void *argp1 = 0 ;
7399  int res1 = 0 ;
7400  void *argp2 = 0 ;
7401  int res2 = 0 ;
7402  PyObject * obj0 = 0 ;
7403  PyObject * obj1 = 0 ;
7404  bool result;
7405 
7406  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix6___lt__",&obj0,&obj1)) SWIG_fail;
7407  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7408  if (!SWIG_IsOK(res1)) {
7409  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6___lt__" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
7410  }
7411  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7412  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
7413  if (!SWIG_IsOK(res2)) {
7414  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6___lt__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
7415  }
7416  if (!argp2) {
7417  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix6___lt__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
7418  }
7419  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
7420  result = (bool)((libbgp::Prefix6 const *)arg1)->operator <((libbgp::Prefix const &)*arg2);
7421  resultobj = SWIG_From_bool(static_cast< bool >(result));
7422  return resultobj;
7423 fail:
7424  return NULL;
7425 }
7426 
7427 
7428 SWIGINTERN PyObject *_wrap_Prefix6___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7429  PyObject *resultobj = 0;
7430  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7431  libbgp::Prefix *arg2 = 0 ;
7432  void *argp1 = 0 ;
7433  int res1 = 0 ;
7434  void *argp2 = 0 ;
7435  int res2 = 0 ;
7436  PyObject * obj0 = 0 ;
7437  PyObject * obj1 = 0 ;
7438  bool result;
7439 
7440  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix6___ge__",&obj0,&obj1)) SWIG_fail;
7441  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7442  if (!SWIG_IsOK(res1)) {
7443  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6___ge__" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
7444  }
7445  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7446  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
7447  if (!SWIG_IsOK(res2)) {
7448  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6___ge__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
7449  }
7450  if (!argp2) {
7451  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix6___ge__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
7452  }
7453  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
7454  result = (bool)((libbgp::Prefix6 const *)arg1)->operator >=((libbgp::Prefix const &)*arg2);
7455  resultobj = SWIG_From_bool(static_cast< bool >(result));
7456  return resultobj;
7457 fail:
7458  return NULL;
7459 }
7460 
7461 
7462 SWIGINTERN PyObject *_wrap_Prefix6___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7463  PyObject *resultobj = 0;
7464  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7465  libbgp::Prefix *arg2 = 0 ;
7466  void *argp1 = 0 ;
7467  int res1 = 0 ;
7468  void *argp2 = 0 ;
7469  int res2 = 0 ;
7470  PyObject * obj0 = 0 ;
7471  PyObject * obj1 = 0 ;
7472  bool result;
7473 
7474  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix6___le__",&obj0,&obj1)) SWIG_fail;
7475  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7476  if (!SWIG_IsOK(res1)) {
7477  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6___le__" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
7478  }
7479  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7480  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
7481  if (!SWIG_IsOK(res2)) {
7482  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6___le__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
7483  }
7484  if (!argp2) {
7485  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix6___le__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
7486  }
7487  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
7488  result = (bool)((libbgp::Prefix6 const *)arg1)->operator <=((libbgp::Prefix const &)*arg2);
7489  resultobj = SWIG_From_bool(static_cast< bool >(result));
7490  return resultobj;
7491 fail:
7492  return NULL;
7493 }
7494 
7495 
7496 SWIGINTERN PyObject *_wrap_Prefix6___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7497  PyObject *resultobj = 0;
7498  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7499  libbgp::Prefix *arg2 = 0 ;
7500  void *argp1 = 0 ;
7501  int res1 = 0 ;
7502  void *argp2 = 0 ;
7503  int res2 = 0 ;
7504  PyObject * obj0 = 0 ;
7505  PyObject * obj1 = 0 ;
7506  bool result;
7507 
7508  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix6___ne__",&obj0,&obj1)) SWIG_fail;
7509  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7510  if (!SWIG_IsOK(res1)) {
7511  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6___ne__" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
7512  }
7513  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7514  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
7515  if (!SWIG_IsOK(res2)) {
7516  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6___ne__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
7517  }
7518  if (!argp2) {
7519  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix6___ne__" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
7520  }
7521  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
7522  result = (bool)((libbgp::Prefix6 const *)arg1)->operator !=((libbgp::Prefix const &)*arg2);
7523  resultobj = SWIG_From_bool(static_cast< bool >(result));
7524  return resultobj;
7525 fail:
7526  return NULL;
7527 }
7528 
7529 
7530 SWIGINTERN PyObject *_wrap_Prefix6_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7531  PyObject *resultobj = 0;
7532  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7533  uint8_t *arg2 ;
7534  uint8_t arg3 ;
7535  void *argp1 = 0 ;
7536  int res1 = 0 ;
7537  void *argp2 = 0 ;
7538  int res2 = 0 ;
7539  unsigned char val3 ;
7540  int ecode3 = 0 ;
7541  PyObject * obj0 = 0 ;
7542  PyObject * obj1 = 0 ;
7543  PyObject * obj2 = 0 ;
7544  bool result;
7545 
7546  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix6_set",&obj0,&obj1,&obj2)) SWIG_fail;
7547  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7548  if (!SWIG_IsOK(res1)) {
7549  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_set" "', argument " "1"" of type '" "libbgp::Prefix6 *""'");
7550  }
7551  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7552  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
7553  if (!SWIG_IsOK(res2)) {
7554  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6_set" "', argument " "2"" of type '" "uint8_t const [16]""'");
7555  }
7556  arg2 = reinterpret_cast< uint8_t * >(argp2);
7557  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
7558  if (!SWIG_IsOK(ecode3)) {
7559  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Prefix6_set" "', argument " "3"" of type '" "uint8_t""'");
7560  }
7561  arg3 = static_cast< uint8_t >(val3);
7562  result = (bool)(arg1)->set((uint8_t const (*))arg2,arg3);
7563  resultobj = SWIG_From_bool(static_cast< bool >(result));
7564  return resultobj;
7565 fail:
7566  return NULL;
7567 }
7568 
7569 
7570 SWIGINTERN PyObject *_wrap_Prefix6_setPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7571  PyObject *resultobj = 0;
7572  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7573  uint8_t *arg2 ;
7574  void *argp1 = 0 ;
7575  int res1 = 0 ;
7576  void *argp2 = 0 ;
7577  int res2 = 0 ;
7578  PyObject * obj0 = 0 ;
7579  PyObject * obj1 = 0 ;
7580  bool result;
7581 
7582  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix6_setPrefix",&obj0,&obj1)) SWIG_fail;
7583  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7584  if (!SWIG_IsOK(res1)) {
7585  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_setPrefix" "', argument " "1"" of type '" "libbgp::Prefix6 *""'");
7586  }
7587  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7588  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
7589  if (!SWIG_IsOK(res2)) {
7590  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6_setPrefix" "', argument " "2"" of type '" "uint8_t const [16]""'");
7591  }
7592  arg2 = reinterpret_cast< uint8_t * >(argp2);
7593  result = (bool)(arg1)->setPrefix((uint8_t const (*))arg2);
7594  resultobj = SWIG_From_bool(static_cast< bool >(result));
7595  return resultobj;
7596 fail:
7597  return NULL;
7598 }
7599 
7600 
7601 SWIGINTERN PyObject *_wrap_Prefix6_setLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7602  PyObject *resultobj = 0;
7603  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7604  uint8_t arg2 ;
7605  void *argp1 = 0 ;
7606  int res1 = 0 ;
7607  unsigned char val2 ;
7608  int ecode2 = 0 ;
7609  PyObject * obj0 = 0 ;
7610  PyObject * obj1 = 0 ;
7611  bool result;
7612 
7613  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix6_setLength",&obj0,&obj1)) SWIG_fail;
7614  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7615  if (!SWIG_IsOK(res1)) {
7616  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_setLength" "', argument " "1"" of type '" "libbgp::Prefix6 *""'");
7617  }
7618  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7619  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
7620  if (!SWIG_IsOK(ecode2)) {
7621  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Prefix6_setLength" "', argument " "2"" of type '" "uint8_t""'");
7622  }
7623  arg2 = static_cast< uint8_t >(val2);
7624  result = (bool)(arg1)->setLength(arg2);
7625  resultobj = SWIG_From_bool(static_cast< bool >(result));
7626  return resultobj;
7627 fail:
7628  return NULL;
7629 }
7630 
7631 
7632 SWIGINTERN PyObject *_wrap_Prefix6_getPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7633  PyObject *resultobj = 0;
7634  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7635  uint8_t *arg2 ;
7636  void *argp1 = 0 ;
7637  int res1 = 0 ;
7638  void *argp2 = 0 ;
7639  int res2 = 0 ;
7640  PyObject * obj0 = 0 ;
7641  PyObject * obj1 = 0 ;
7642 
7643  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix6_getPrefix",&obj0,&obj1)) SWIG_fail;
7644  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7645  if (!SWIG_IsOK(res1)) {
7646  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_getPrefix" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
7647  }
7648  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7649  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
7650  if (!SWIG_IsOK(res2)) {
7651  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6_getPrefix" "', argument " "2"" of type '" "uint8_t [16]""'");
7652  }
7653  arg2 = reinterpret_cast< uint8_t * >(argp2);
7654  ((libbgp::Prefix6 const *)arg1)->getPrefix(arg2);
7655  resultobj = SWIG_Py_Void();
7656  return resultobj;
7657 fail:
7658  return NULL;
7659 }
7660 
7661 
7662 SWIGINTERN PyObject *_wrap_Prefix6_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7663  PyObject *resultobj = 0;
7664  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7665  void *argp1 = 0 ;
7666  int res1 = 0 ;
7667  PyObject * obj0 = 0 ;
7668  uint8_t result;
7669 
7670  if (!PyArg_ParseTuple(args,(char *)"O:Prefix6_getLength",&obj0)) SWIG_fail;
7671  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7672  if (!SWIG_IsOK(res1)) {
7673  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_getLength" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
7674  }
7675  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7676  result = (uint8_t)((libbgp::Prefix6 const *)arg1)->getLength();
7677  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
7678  return resultobj;
7679 fail:
7680  return NULL;
7681 }
7682 
7683 
7684 SWIGINTERN PyObject *_wrap_Prefix6_getMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7685  PyObject *resultobj = 0;
7686  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7687  uint8_t *arg2 ;
7688  void *argp1 = 0 ;
7689  int res1 = 0 ;
7690  void *argp2 = 0 ;
7691  int res2 = 0 ;
7692  PyObject * obj0 = 0 ;
7693  PyObject * obj1 = 0 ;
7694 
7695  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix6_getMask",&obj0,&obj1)) SWIG_fail;
7696  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
7697  if (!SWIG_IsOK(res1)) {
7698  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6_getMask" "', argument " "1"" of type '" "libbgp::Prefix6 const *""'");
7699  }
7700  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7701  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
7702  if (!SWIG_IsOK(res2)) {
7703  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6_getMask" "', argument " "2"" of type '" "uint8_t [16]""'");
7704  }
7705  arg2 = reinterpret_cast< uint8_t * >(argp2);
7706  ((libbgp::Prefix6 const *)arg1)->getMask(arg2);
7707  resultobj = SWIG_Py_Void();
7708  return resultobj;
7709 fail:
7710  return NULL;
7711 }
7712 
7713 
7714 SWIGINTERN PyObject *_wrap_delete_Prefix6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7715  PyObject *resultobj = 0;
7716  libbgp::Prefix6 *arg1 = (libbgp::Prefix6 *) 0 ;
7717  void *argp1 = 0 ;
7718  int res1 = 0 ;
7719  PyObject * obj0 = 0 ;
7720 
7721  if (!PyArg_ParseTuple(args,(char *)"O:delete_Prefix6",&obj0)) SWIG_fail;
7722  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Prefix6, SWIG_POINTER_DISOWN | 0 );
7723  if (!SWIG_IsOK(res1)) {
7724  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Prefix6" "', argument " "1"" of type '" "libbgp::Prefix6 *""'");
7725  }
7726  arg1 = reinterpret_cast< libbgp::Prefix6 * >(argp1);
7727  delete arg1;
7728  resultobj = SWIG_Py_Void();
7729  return resultobj;
7730 fail:
7731  return NULL;
7732 }
7733 
7734 
7735 SWIGINTERN PyObject *Prefix6_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7736  PyObject *obj;
7737  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
7738  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__Prefix6, SWIG_NewClientData(obj));
7739  return SWIG_Py_Void();
7740 }
7741 
7742 SWIGINTERN PyObject *_wrap_BgpCapability_code_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7743  PyObject *resultobj = 0;
7745  uint8_t arg2 ;
7746  void *argp1 = 0 ;
7747  int res1 = 0 ;
7748  unsigned char val2 ;
7749  int ecode2 = 0 ;
7750  PyObject * obj0 = 0 ;
7751  PyObject * obj1 = 0 ;
7752 
7753  if (!PyArg_ParseTuple(args,(char *)"OO:BgpCapability_code_set",&obj0,&obj1)) SWIG_fail;
7754  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapability, 0 | 0 );
7755  if (!SWIG_IsOK(res1)) {
7756  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapability_code_set" "', argument " "1"" of type '" "libbgp::BgpCapability *""'");
7757  }
7758  arg1 = reinterpret_cast< libbgp::BgpCapability * >(argp1);
7759  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
7760  if (!SWIG_IsOK(ecode2)) {
7761  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpCapability_code_set" "', argument " "2"" of type '" "uint8_t""'");
7762  }
7763  arg2 = static_cast< uint8_t >(val2);
7764  if (arg1) (arg1)->code = arg2;
7765  resultobj = SWIG_Py_Void();
7766  return resultobj;
7767 fail:
7768  return NULL;
7769 }
7770 
7771 
7772 SWIGINTERN PyObject *_wrap_BgpCapability_code_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7773  PyObject *resultobj = 0;
7775  void *argp1 = 0 ;
7776  int res1 = 0 ;
7777  PyObject * obj0 = 0 ;
7778  uint8_t result;
7779 
7780  if (!PyArg_ParseTuple(args,(char *)"O:BgpCapability_code_get",&obj0)) SWIG_fail;
7781  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapability, 0 | 0 );
7782  if (!SWIG_IsOK(res1)) {
7783  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapability_code_get" "', argument " "1"" of type '" "libbgp::BgpCapability *""'");
7784  }
7785  arg1 = reinterpret_cast< libbgp::BgpCapability * >(argp1);
7786  result = (uint8_t) ((arg1)->code);
7787  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
7788  return resultobj;
7789 fail:
7790  return NULL;
7791 }
7792 
7793 
7794 SWIGINTERN PyObject *_wrap_delete_BgpCapability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7795  PyObject *resultobj = 0;
7797  void *argp1 = 0 ;
7798  int res1 = 0 ;
7799  PyObject * obj0 = 0 ;
7800 
7801  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpCapability",&obj0)) SWIG_fail;
7802  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapability, SWIG_POINTER_DISOWN | 0 );
7803  if (!SWIG_IsOK(res1)) {
7804  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpCapability" "', argument " "1"" of type '" "libbgp::BgpCapability *""'");
7805  }
7806  arg1 = reinterpret_cast< libbgp::BgpCapability * >(argp1);
7807  delete arg1;
7808  resultobj = SWIG_Py_Void();
7809  return resultobj;
7810 fail:
7811  return NULL;
7812 }
7813 
7814 
7815 SWIGINTERN PyObject *_wrap_BgpCapability_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7816  PyObject *resultobj = 0;
7818  uint8_t *arg2 = (uint8_t *) 0 ;
7819  size_t arg3 ;
7820  void *argp1 = 0 ;
7821  int res1 = 0 ;
7822  void *argp2 = 0 ;
7823  int res2 = 0 ;
7824  size_t val3 ;
7825  int ecode3 = 0 ;
7826  PyObject * obj0 = 0 ;
7827  PyObject * obj1 = 0 ;
7828  PyObject * obj2 = 0 ;
7829  ssize_t result;
7830 
7831  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpCapability_parse",&obj0,&obj1,&obj2)) SWIG_fail;
7832  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapability, 0 | 0 );
7833  if (!SWIG_IsOK(res1)) {
7834  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapability_parse" "', argument " "1"" of type '" "libbgp::BgpCapability *""'");
7835  }
7836  arg1 = reinterpret_cast< libbgp::BgpCapability * >(argp1);
7837  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
7838  if (!SWIG_IsOK(res2)) {
7839  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpCapability_parse" "', argument " "2"" of type '" "uint8_t const *""'");
7840  }
7841  arg2 = reinterpret_cast< uint8_t * >(argp2);
7842  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
7843  if (!SWIG_IsOK(ecode3)) {
7844  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpCapability_parse" "', argument " "3"" of type '" "size_t""'");
7845  }
7846  arg3 = static_cast< size_t >(val3);
7847  result = (arg1)->parse((uint8_t const *)arg2,arg3);
7848  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
7849  return resultobj;
7850 fail:
7851  return NULL;
7852 }
7853 
7854 
7855 SWIGINTERN PyObject *_wrap_BgpCapability_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7856  PyObject *resultobj = 0;
7858  uint8_t *arg2 = (uint8_t *) 0 ;
7859  size_t arg3 ;
7860  void *argp1 = 0 ;
7861  int res1 = 0 ;
7862  void *argp2 = 0 ;
7863  int res2 = 0 ;
7864  size_t val3 ;
7865  int ecode3 = 0 ;
7866  PyObject * obj0 = 0 ;
7867  PyObject * obj1 = 0 ;
7868  PyObject * obj2 = 0 ;
7869  ssize_t result;
7870 
7871  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpCapability_write",&obj0,&obj1,&obj2)) SWIG_fail;
7872  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapability, 0 | 0 );
7873  if (!SWIG_IsOK(res1)) {
7874  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapability_write" "', argument " "1"" of type '" "libbgp::BgpCapability const *""'");
7875  }
7876  arg1 = reinterpret_cast< libbgp::BgpCapability * >(argp1);
7877  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
7878  if (!SWIG_IsOK(res2)) {
7879  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpCapability_write" "', argument " "2"" of type '" "uint8_t *""'");
7880  }
7881  arg2 = reinterpret_cast< uint8_t * >(argp2);
7882  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
7883  if (!SWIG_IsOK(ecode3)) {
7884  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpCapability_write" "', argument " "3"" of type '" "size_t""'");
7885  }
7886  arg3 = static_cast< size_t >(val3);
7887  result = ((libbgp::BgpCapability const *)arg1)->write(arg2,arg3);
7888  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
7889  return resultobj;
7890 fail:
7891  return NULL;
7892 }
7893 
7894 
7895 SWIGINTERN PyObject *BgpCapability_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7896  PyObject *obj;
7897  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
7898  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpCapability, SWIG_NewClientData(obj));
7899  return SWIG_Py_Void();
7900 }
7901 
7902 SWIGINTERN PyObject *_wrap_new_BgpCapability4BytesAsn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7903  PyObject *resultobj = 0;
7905  void *argp1 = 0 ;
7906  int res1 = 0 ;
7907  PyObject * obj0 = 0 ;
7908  libbgp::BgpCapability4BytesAsn *result = 0 ;
7909 
7910  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpCapability4BytesAsn",&obj0)) SWIG_fail;
7911  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
7912  if (!SWIG_IsOK(res1)) {
7913  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpCapability4BytesAsn" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
7914  }
7915  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
7917  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpCapability4BytesAsn, SWIG_POINTER_NEW | 0 );
7918  return resultobj;
7919 fail:
7920  return NULL;
7921 }
7922 
7923 
7924 SWIGINTERN PyObject *_wrap_BgpCapability4BytesAsn_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7925  PyObject *resultobj = 0;
7927  size_t arg2 ;
7928  uint8_t **arg3 = (uint8_t **) 0 ;
7929  size_t *arg4 = (size_t *) 0 ;
7930  void *argp1 = 0 ;
7931  int res1 = 0 ;
7932  size_t val2 ;
7933  int ecode2 = 0 ;
7934  void *argp3 = 0 ;
7935  int res3 = 0 ;
7936  void *argp4 = 0 ;
7937  int res4 = 0 ;
7938  PyObject * obj0 = 0 ;
7939  PyObject * obj1 = 0 ;
7940  PyObject * obj2 = 0 ;
7941  PyObject * obj3 = 0 ;
7942  ssize_t result;
7943 
7944  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpCapability4BytesAsn_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
7945  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapability4BytesAsn, 0 | 0 );
7946  if (!SWIG_IsOK(res1)) {
7947  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapability4BytesAsn_doPrint" "', argument " "1"" of type '" "libbgp::BgpCapability4BytesAsn const *""'");
7948  }
7949  arg1 = reinterpret_cast< libbgp::BgpCapability4BytesAsn * >(argp1);
7950  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
7951  if (!SWIG_IsOK(ecode2)) {
7952  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpCapability4BytesAsn_doPrint" "', argument " "2"" of type '" "size_t""'");
7953  }
7954  arg2 = static_cast< size_t >(val2);
7955  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
7956  if (!SWIG_IsOK(res3)) {
7957  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpCapability4BytesAsn_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
7958  }
7959  arg3 = reinterpret_cast< uint8_t ** >(argp3);
7960  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
7961  if (!SWIG_IsOK(res4)) {
7962  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpCapability4BytesAsn_doPrint" "', argument " "4"" of type '" "size_t *""'");
7963  }
7964  arg4 = reinterpret_cast< size_t * >(argp4);
7965  result = ((libbgp::BgpCapability4BytesAsn const *)arg1)->doPrint(arg2,arg3,arg4);
7966  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
7967  return resultobj;
7968 fail:
7969  return NULL;
7970 }
7971 
7972 
7973 SWIGINTERN PyObject *_wrap_BgpCapability4BytesAsn_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7974  PyObject *resultobj = 0;
7976  uint8_t *arg2 = (uint8_t *) 0 ;
7977  size_t arg3 ;
7978  void *argp1 = 0 ;
7979  int res1 = 0 ;
7980  void *argp2 = 0 ;
7981  int res2 = 0 ;
7982  size_t val3 ;
7983  int ecode3 = 0 ;
7984  PyObject * obj0 = 0 ;
7985  PyObject * obj1 = 0 ;
7986  PyObject * obj2 = 0 ;
7987  ssize_t result;
7988 
7989  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpCapability4BytesAsn_parse",&obj0,&obj1,&obj2)) SWIG_fail;
7990  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapability4BytesAsn, 0 | 0 );
7991  if (!SWIG_IsOK(res1)) {
7992  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapability4BytesAsn_parse" "', argument " "1"" of type '" "libbgp::BgpCapability4BytesAsn *""'");
7993  }
7994  arg1 = reinterpret_cast< libbgp::BgpCapability4BytesAsn * >(argp1);
7995  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
7996  if (!SWIG_IsOK(res2)) {
7997  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpCapability4BytesAsn_parse" "', argument " "2"" of type '" "uint8_t const *""'");
7998  }
7999  arg2 = reinterpret_cast< uint8_t * >(argp2);
8000  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8001  if (!SWIG_IsOK(ecode3)) {
8002  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpCapability4BytesAsn_parse" "', argument " "3"" of type '" "size_t""'");
8003  }
8004  arg3 = static_cast< size_t >(val3);
8005  result = (arg1)->parse((uint8_t const *)arg2,arg3);
8006  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
8007  return resultobj;
8008 fail:
8009  return NULL;
8010 }
8011 
8012 
8013 SWIGINTERN PyObject *_wrap_BgpCapability4BytesAsn_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8014  PyObject *resultobj = 0;
8016  uint8_t *arg2 = (uint8_t *) 0 ;
8017  size_t arg3 ;
8018  void *argp1 = 0 ;
8019  int res1 = 0 ;
8020  void *argp2 = 0 ;
8021  int res2 = 0 ;
8022  size_t val3 ;
8023  int ecode3 = 0 ;
8024  PyObject * obj0 = 0 ;
8025  PyObject * obj1 = 0 ;
8026  PyObject * obj2 = 0 ;
8027  ssize_t result;
8028 
8029  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpCapability4BytesAsn_write",&obj0,&obj1,&obj2)) SWIG_fail;
8030  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapability4BytesAsn, 0 | 0 );
8031  if (!SWIG_IsOK(res1)) {
8032  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapability4BytesAsn_write" "', argument " "1"" of type '" "libbgp::BgpCapability4BytesAsn const *""'");
8033  }
8034  arg1 = reinterpret_cast< libbgp::BgpCapability4BytesAsn * >(argp1);
8035  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
8036  if (!SWIG_IsOK(res2)) {
8037  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpCapability4BytesAsn_write" "', argument " "2"" of type '" "uint8_t *""'");
8038  }
8039  arg2 = reinterpret_cast< uint8_t * >(argp2);
8040  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8041  if (!SWIG_IsOK(ecode3)) {
8042  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpCapability4BytesAsn_write" "', argument " "3"" of type '" "size_t""'");
8043  }
8044  arg3 = static_cast< size_t >(val3);
8045  result = ((libbgp::BgpCapability4BytesAsn const *)arg1)->write(arg2,arg3);
8046  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
8047  return resultobj;
8048 fail:
8049  return NULL;
8050 }
8051 
8052 
8053 SWIGINTERN PyObject *_wrap_BgpCapability4BytesAsn_my_asn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8054  PyObject *resultobj = 0;
8056  uint32_t arg2 ;
8057  void *argp1 = 0 ;
8058  int res1 = 0 ;
8059  unsigned int val2 ;
8060  int ecode2 = 0 ;
8061  PyObject * obj0 = 0 ;
8062  PyObject * obj1 = 0 ;
8063 
8064  if (!PyArg_ParseTuple(args,(char *)"OO:BgpCapability4BytesAsn_my_asn_set",&obj0,&obj1)) SWIG_fail;
8065  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapability4BytesAsn, 0 | 0 );
8066  if (!SWIG_IsOK(res1)) {
8067  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapability4BytesAsn_my_asn_set" "', argument " "1"" of type '" "libbgp::BgpCapability4BytesAsn *""'");
8068  }
8069  arg1 = reinterpret_cast< libbgp::BgpCapability4BytesAsn * >(argp1);
8070  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8071  if (!SWIG_IsOK(ecode2)) {
8072  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpCapability4BytesAsn_my_asn_set" "', argument " "2"" of type '" "uint32_t""'");
8073  }
8074  arg2 = static_cast< uint32_t >(val2);
8075  if (arg1) (arg1)->my_asn = arg2;
8076  resultobj = SWIG_Py_Void();
8077  return resultobj;
8078 fail:
8079  return NULL;
8080 }
8081 
8082 
8083 SWIGINTERN PyObject *_wrap_BgpCapability4BytesAsn_my_asn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8084  PyObject *resultobj = 0;
8086  void *argp1 = 0 ;
8087  int res1 = 0 ;
8088  PyObject * obj0 = 0 ;
8089  uint32_t result;
8090 
8091  if (!PyArg_ParseTuple(args,(char *)"O:BgpCapability4BytesAsn_my_asn_get",&obj0)) SWIG_fail;
8092  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapability4BytesAsn, 0 | 0 );
8093  if (!SWIG_IsOK(res1)) {
8094  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapability4BytesAsn_my_asn_get" "', argument " "1"" of type '" "libbgp::BgpCapability4BytesAsn *""'");
8095  }
8096  arg1 = reinterpret_cast< libbgp::BgpCapability4BytesAsn * >(argp1);
8097  result = (uint32_t) ((arg1)->my_asn);
8098  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
8099  return resultobj;
8100 fail:
8101  return NULL;
8102 }
8103 
8104 
8105 SWIGINTERN PyObject *_wrap_delete_BgpCapability4BytesAsn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8106  PyObject *resultobj = 0;
8108  void *argp1 = 0 ;
8109  int res1 = 0 ;
8110  PyObject * obj0 = 0 ;
8111 
8112  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpCapability4BytesAsn",&obj0)) SWIG_fail;
8113  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapability4BytesAsn, SWIG_POINTER_DISOWN | 0 );
8114  if (!SWIG_IsOK(res1)) {
8115  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpCapability4BytesAsn" "', argument " "1"" of type '" "libbgp::BgpCapability4BytesAsn *""'");
8116  }
8117  arg1 = reinterpret_cast< libbgp::BgpCapability4BytesAsn * >(argp1);
8118  delete arg1;
8119  resultobj = SWIG_Py_Void();
8120  return resultobj;
8121 fail:
8122  return NULL;
8123 }
8124 
8125 
8126 SWIGINTERN PyObject *BgpCapability4BytesAsn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8127  PyObject *obj;
8128  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
8129  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpCapability4BytesAsn, SWIG_NewClientData(obj));
8130  return SWIG_Py_Void();
8131 }
8132 
8133 SWIGINTERN PyObject *_wrap_new_BgpCapabilityMpBgp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8134  PyObject *resultobj = 0;
8136  void *argp1 = 0 ;
8137  int res1 = 0 ;
8138  PyObject * obj0 = 0 ;
8139  libbgp::BgpCapabilityMpBgp *result = 0 ;
8140 
8141  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpCapabilityMpBgp",&obj0)) SWIG_fail;
8142  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
8143  if (!SWIG_IsOK(res1)) {
8144  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpCapabilityMpBgp" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
8145  }
8146  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
8148  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpCapabilityMpBgp, SWIG_POINTER_NEW | 0 );
8149  return resultobj;
8150 fail:
8151  return NULL;
8152 }
8153 
8154 
8155 SWIGINTERN PyObject *_wrap_BgpCapabilityMpBgp_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8156  PyObject *resultobj = 0;
8158  size_t arg2 ;
8159  uint8_t **arg3 = (uint8_t **) 0 ;
8160  size_t *arg4 = (size_t *) 0 ;
8161  void *argp1 = 0 ;
8162  int res1 = 0 ;
8163  size_t val2 ;
8164  int ecode2 = 0 ;
8165  void *argp3 = 0 ;
8166  int res3 = 0 ;
8167  void *argp4 = 0 ;
8168  int res4 = 0 ;
8169  PyObject * obj0 = 0 ;
8170  PyObject * obj1 = 0 ;
8171  PyObject * obj2 = 0 ;
8172  PyObject * obj3 = 0 ;
8173  ssize_t result;
8174 
8175  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpCapabilityMpBgp_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8176  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapabilityMpBgp, 0 | 0 );
8177  if (!SWIG_IsOK(res1)) {
8178  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapabilityMpBgp_doPrint" "', argument " "1"" of type '" "libbgp::BgpCapabilityMpBgp const *""'");
8179  }
8180  arg1 = reinterpret_cast< libbgp::BgpCapabilityMpBgp * >(argp1);
8181  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8182  if (!SWIG_IsOK(ecode2)) {
8183  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpCapabilityMpBgp_doPrint" "', argument " "2"" of type '" "size_t""'");
8184  }
8185  arg2 = static_cast< size_t >(val2);
8186  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
8187  if (!SWIG_IsOK(res3)) {
8188  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpCapabilityMpBgp_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
8189  }
8190  arg3 = reinterpret_cast< uint8_t ** >(argp3);
8191  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
8192  if (!SWIG_IsOK(res4)) {
8193  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpCapabilityMpBgp_doPrint" "', argument " "4"" of type '" "size_t *""'");
8194  }
8195  arg4 = reinterpret_cast< size_t * >(argp4);
8196  result = ((libbgp::BgpCapabilityMpBgp const *)arg1)->doPrint(arg2,arg3,arg4);
8197  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
8198  return resultobj;
8199 fail:
8200  return NULL;
8201 }
8202 
8203 
8204 SWIGINTERN PyObject *_wrap_BgpCapabilityMpBgp_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8205  PyObject *resultobj = 0;
8207  uint8_t *arg2 = (uint8_t *) 0 ;
8208  size_t arg3 ;
8209  void *argp1 = 0 ;
8210  int res1 = 0 ;
8211  void *argp2 = 0 ;
8212  int res2 = 0 ;
8213  size_t val3 ;
8214  int ecode3 = 0 ;
8215  PyObject * obj0 = 0 ;
8216  PyObject * obj1 = 0 ;
8217  PyObject * obj2 = 0 ;
8218  ssize_t result;
8219 
8220  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpCapabilityMpBgp_parse",&obj0,&obj1,&obj2)) SWIG_fail;
8221  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapabilityMpBgp, 0 | 0 );
8222  if (!SWIG_IsOK(res1)) {
8223  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapabilityMpBgp_parse" "', argument " "1"" of type '" "libbgp::BgpCapabilityMpBgp *""'");
8224  }
8225  arg1 = reinterpret_cast< libbgp::BgpCapabilityMpBgp * >(argp1);
8226  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
8227  if (!SWIG_IsOK(res2)) {
8228  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpCapabilityMpBgp_parse" "', argument " "2"" of type '" "uint8_t const *""'");
8229  }
8230  arg2 = reinterpret_cast< uint8_t * >(argp2);
8231  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8232  if (!SWIG_IsOK(ecode3)) {
8233  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpCapabilityMpBgp_parse" "', argument " "3"" of type '" "size_t""'");
8234  }
8235  arg3 = static_cast< size_t >(val3);
8236  result = (arg1)->parse((uint8_t const *)arg2,arg3);
8237  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
8238  return resultobj;
8239 fail:
8240  return NULL;
8241 }
8242 
8243 
8244 SWIGINTERN PyObject *_wrap_BgpCapabilityMpBgp_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8245  PyObject *resultobj = 0;
8247  uint8_t *arg2 = (uint8_t *) 0 ;
8248  size_t arg3 ;
8249  void *argp1 = 0 ;
8250  int res1 = 0 ;
8251  void *argp2 = 0 ;
8252  int res2 = 0 ;
8253  size_t val3 ;
8254  int ecode3 = 0 ;
8255  PyObject * obj0 = 0 ;
8256  PyObject * obj1 = 0 ;
8257  PyObject * obj2 = 0 ;
8258  ssize_t result;
8259 
8260  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpCapabilityMpBgp_write",&obj0,&obj1,&obj2)) SWIG_fail;
8261  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapabilityMpBgp, 0 | 0 );
8262  if (!SWIG_IsOK(res1)) {
8263  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapabilityMpBgp_write" "', argument " "1"" of type '" "libbgp::BgpCapabilityMpBgp const *""'");
8264  }
8265  arg1 = reinterpret_cast< libbgp::BgpCapabilityMpBgp * >(argp1);
8266  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
8267  if (!SWIG_IsOK(res2)) {
8268  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpCapabilityMpBgp_write" "', argument " "2"" of type '" "uint8_t *""'");
8269  }
8270  arg2 = reinterpret_cast< uint8_t * >(argp2);
8271  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8272  if (!SWIG_IsOK(ecode3)) {
8273  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpCapabilityMpBgp_write" "', argument " "3"" of type '" "size_t""'");
8274  }
8275  arg3 = static_cast< size_t >(val3);
8276  result = ((libbgp::BgpCapabilityMpBgp const *)arg1)->write(arg2,arg3);
8277  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
8278  return resultobj;
8279 fail:
8280  return NULL;
8281 }
8282 
8283 
8284 SWIGINTERN PyObject *_wrap_BgpCapabilityMpBgp_afi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8285  PyObject *resultobj = 0;
8287  uint16_t arg2 ;
8288  void *argp1 = 0 ;
8289  int res1 = 0 ;
8290  unsigned short val2 ;
8291  int ecode2 = 0 ;
8292  PyObject * obj0 = 0 ;
8293  PyObject * obj1 = 0 ;
8294 
8295  if (!PyArg_ParseTuple(args,(char *)"OO:BgpCapabilityMpBgp_afi_set",&obj0,&obj1)) SWIG_fail;
8296  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapabilityMpBgp, 0 | 0 );
8297  if (!SWIG_IsOK(res1)) {
8298  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapabilityMpBgp_afi_set" "', argument " "1"" of type '" "libbgp::BgpCapabilityMpBgp *""'");
8299  }
8300  arg1 = reinterpret_cast< libbgp::BgpCapabilityMpBgp * >(argp1);
8301  ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
8302  if (!SWIG_IsOK(ecode2)) {
8303  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpCapabilityMpBgp_afi_set" "', argument " "2"" of type '" "uint16_t""'");
8304  }
8305  arg2 = static_cast< uint16_t >(val2);
8306  if (arg1) (arg1)->afi = arg2;
8307  resultobj = SWIG_Py_Void();
8308  return resultobj;
8309 fail:
8310  return NULL;
8311 }
8312 
8313 
8314 SWIGINTERN PyObject *_wrap_BgpCapabilityMpBgp_afi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8315  PyObject *resultobj = 0;
8317  void *argp1 = 0 ;
8318  int res1 = 0 ;
8319  PyObject * obj0 = 0 ;
8320  uint16_t result;
8321 
8322  if (!PyArg_ParseTuple(args,(char *)"O:BgpCapabilityMpBgp_afi_get",&obj0)) SWIG_fail;
8323  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapabilityMpBgp, 0 | 0 );
8324  if (!SWIG_IsOK(res1)) {
8325  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapabilityMpBgp_afi_get" "', argument " "1"" of type '" "libbgp::BgpCapabilityMpBgp *""'");
8326  }
8327  arg1 = reinterpret_cast< libbgp::BgpCapabilityMpBgp * >(argp1);
8328  result = (uint16_t) ((arg1)->afi);
8329  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
8330  return resultobj;
8331 fail:
8332  return NULL;
8333 }
8334 
8335 
8336 SWIGINTERN PyObject *_wrap_BgpCapabilityMpBgp_safi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8337  PyObject *resultobj = 0;
8339  uint8_t arg2 ;
8340  void *argp1 = 0 ;
8341  int res1 = 0 ;
8342  unsigned char val2 ;
8343  int ecode2 = 0 ;
8344  PyObject * obj0 = 0 ;
8345  PyObject * obj1 = 0 ;
8346 
8347  if (!PyArg_ParseTuple(args,(char *)"OO:BgpCapabilityMpBgp_safi_set",&obj0,&obj1)) SWIG_fail;
8348  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapabilityMpBgp, 0 | 0 );
8349  if (!SWIG_IsOK(res1)) {
8350  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapabilityMpBgp_safi_set" "', argument " "1"" of type '" "libbgp::BgpCapabilityMpBgp *""'");
8351  }
8352  arg1 = reinterpret_cast< libbgp::BgpCapabilityMpBgp * >(argp1);
8353  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
8354  if (!SWIG_IsOK(ecode2)) {
8355  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpCapabilityMpBgp_safi_set" "', argument " "2"" of type '" "uint8_t""'");
8356  }
8357  arg2 = static_cast< uint8_t >(val2);
8358  if (arg1) (arg1)->safi = arg2;
8359  resultobj = SWIG_Py_Void();
8360  return resultobj;
8361 fail:
8362  return NULL;
8363 }
8364 
8365 
8366 SWIGINTERN PyObject *_wrap_BgpCapabilityMpBgp_safi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8367  PyObject *resultobj = 0;
8369  void *argp1 = 0 ;
8370  int res1 = 0 ;
8371  PyObject * obj0 = 0 ;
8372  uint8_t result;
8373 
8374  if (!PyArg_ParseTuple(args,(char *)"O:BgpCapabilityMpBgp_safi_get",&obj0)) SWIG_fail;
8375  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapabilityMpBgp, 0 | 0 );
8376  if (!SWIG_IsOK(res1)) {
8377  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapabilityMpBgp_safi_get" "', argument " "1"" of type '" "libbgp::BgpCapabilityMpBgp *""'");
8378  }
8379  arg1 = reinterpret_cast< libbgp::BgpCapabilityMpBgp * >(argp1);
8380  result = (uint8_t) ((arg1)->safi);
8381  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
8382  return resultobj;
8383 fail:
8384  return NULL;
8385 }
8386 
8387 
8388 SWIGINTERN PyObject *_wrap_delete_BgpCapabilityMpBgp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8389  PyObject *resultobj = 0;
8391  void *argp1 = 0 ;
8392  int res1 = 0 ;
8393  PyObject * obj0 = 0 ;
8394 
8395  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpCapabilityMpBgp",&obj0)) SWIG_fail;
8396  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapabilityMpBgp, SWIG_POINTER_DISOWN | 0 );
8397  if (!SWIG_IsOK(res1)) {
8398  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpCapabilityMpBgp" "', argument " "1"" of type '" "libbgp::BgpCapabilityMpBgp *""'");
8399  }
8400  arg1 = reinterpret_cast< libbgp::BgpCapabilityMpBgp * >(argp1);
8401  delete arg1;
8402  resultobj = SWIG_Py_Void();
8403  return resultobj;
8404 fail:
8405  return NULL;
8406 }
8407 
8408 
8409 SWIGINTERN PyObject *BgpCapabilityMpBgp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8410  PyObject *obj;
8411  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
8412  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpCapabilityMpBgp, SWIG_NewClientData(obj));
8413  return SWIG_Py_Void();
8414 }
8415 
8416 SWIGINTERN PyObject *_wrap_new_BgpCapabilityUnknow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8417  PyObject *resultobj = 0;
8419  void *argp1 = 0 ;
8420  int res1 = 0 ;
8421  PyObject * obj0 = 0 ;
8422  libbgp::BgpCapabilityUnknow *result = 0 ;
8423 
8424  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpCapabilityUnknow",&obj0)) SWIG_fail;
8425  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
8426  if (!SWIG_IsOK(res1)) {
8427  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpCapabilityUnknow" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
8428  }
8429  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
8431  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpCapabilityUnknow, SWIG_POINTER_NEW | 0 );
8432  return resultobj;
8433 fail:
8434  return NULL;
8435 }
8436 
8437 
8438 SWIGINTERN PyObject *_wrap_delete_BgpCapabilityUnknow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8439  PyObject *resultobj = 0;
8441  void *argp1 = 0 ;
8442  int res1 = 0 ;
8443  PyObject * obj0 = 0 ;
8444 
8445  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpCapabilityUnknow",&obj0)) SWIG_fail;
8446  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapabilityUnknow, SWIG_POINTER_DISOWN | 0 );
8447  if (!SWIG_IsOK(res1)) {
8448  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpCapabilityUnknow" "', argument " "1"" of type '" "libbgp::BgpCapabilityUnknow *""'");
8449  }
8450  arg1 = reinterpret_cast< libbgp::BgpCapabilityUnknow * >(argp1);
8451  delete arg1;
8452  resultobj = SWIG_Py_Void();
8453  return resultobj;
8454 fail:
8455  return NULL;
8456 }
8457 
8458 
8459 SWIGINTERN PyObject *_wrap_BgpCapabilityUnknow_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8460  PyObject *resultobj = 0;
8462  size_t arg2 ;
8463  uint8_t **arg3 = (uint8_t **) 0 ;
8464  size_t *arg4 = (size_t *) 0 ;
8465  void *argp1 = 0 ;
8466  int res1 = 0 ;
8467  size_t val2 ;
8468  int ecode2 = 0 ;
8469  void *argp3 = 0 ;
8470  int res3 = 0 ;
8471  void *argp4 = 0 ;
8472  int res4 = 0 ;
8473  PyObject * obj0 = 0 ;
8474  PyObject * obj1 = 0 ;
8475  PyObject * obj2 = 0 ;
8476  PyObject * obj3 = 0 ;
8477  ssize_t result;
8478 
8479  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpCapabilityUnknow_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
8480  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapabilityUnknow, 0 | 0 );
8481  if (!SWIG_IsOK(res1)) {
8482  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapabilityUnknow_doPrint" "', argument " "1"" of type '" "libbgp::BgpCapabilityUnknow const *""'");
8483  }
8484  arg1 = reinterpret_cast< libbgp::BgpCapabilityUnknow * >(argp1);
8485  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
8486  if (!SWIG_IsOK(ecode2)) {
8487  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpCapabilityUnknow_doPrint" "', argument " "2"" of type '" "size_t""'");
8488  }
8489  arg2 = static_cast< size_t >(val2);
8490  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
8491  if (!SWIG_IsOK(res3)) {
8492  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpCapabilityUnknow_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
8493  }
8494  arg3 = reinterpret_cast< uint8_t ** >(argp3);
8495  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
8496  if (!SWIG_IsOK(res4)) {
8497  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpCapabilityUnknow_doPrint" "', argument " "4"" of type '" "size_t *""'");
8498  }
8499  arg4 = reinterpret_cast< size_t * >(argp4);
8500  result = ((libbgp::BgpCapabilityUnknow const *)arg1)->doPrint(arg2,arg3,arg4);
8501  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
8502  return resultobj;
8503 fail:
8504  return NULL;
8505 }
8506 
8507 
8508 SWIGINTERN PyObject *_wrap_BgpCapabilityUnknow_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8509  PyObject *resultobj = 0;
8511  uint8_t *arg2 = (uint8_t *) 0 ;
8512  size_t arg3 ;
8513  void *argp1 = 0 ;
8514  int res1 = 0 ;
8515  void *argp2 = 0 ;
8516  int res2 = 0 ;
8517  size_t val3 ;
8518  int ecode3 = 0 ;
8519  PyObject * obj0 = 0 ;
8520  PyObject * obj1 = 0 ;
8521  PyObject * obj2 = 0 ;
8522  ssize_t result;
8523 
8524  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpCapabilityUnknow_parse",&obj0,&obj1,&obj2)) SWIG_fail;
8525  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapabilityUnknow, 0 | 0 );
8526  if (!SWIG_IsOK(res1)) {
8527  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapabilityUnknow_parse" "', argument " "1"" of type '" "libbgp::BgpCapabilityUnknow *""'");
8528  }
8529  arg1 = reinterpret_cast< libbgp::BgpCapabilityUnknow * >(argp1);
8530  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
8531  if (!SWIG_IsOK(res2)) {
8532  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpCapabilityUnknow_parse" "', argument " "2"" of type '" "uint8_t const *""'");
8533  }
8534  arg2 = reinterpret_cast< uint8_t * >(argp2);
8535  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8536  if (!SWIG_IsOK(ecode3)) {
8537  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpCapabilityUnknow_parse" "', argument " "3"" of type '" "size_t""'");
8538  }
8539  arg3 = static_cast< size_t >(val3);
8540  result = (arg1)->parse((uint8_t const *)arg2,arg3);
8541  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
8542  return resultobj;
8543 fail:
8544  return NULL;
8545 }
8546 
8547 
8548 SWIGINTERN PyObject *_wrap_BgpCapabilityUnknow_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8549  PyObject *resultobj = 0;
8551  uint8_t *arg2 = (uint8_t *) 0 ;
8552  size_t arg3 ;
8553  void *argp1 = 0 ;
8554  int res1 = 0 ;
8555  void *argp2 = 0 ;
8556  int res2 = 0 ;
8557  size_t val3 ;
8558  int ecode3 = 0 ;
8559  PyObject * obj0 = 0 ;
8560  PyObject * obj1 = 0 ;
8561  PyObject * obj2 = 0 ;
8562  ssize_t result;
8563 
8564  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpCapabilityUnknow_write",&obj0,&obj1,&obj2)) SWIG_fail;
8565  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpCapabilityUnknow, 0 | 0 );
8566  if (!SWIG_IsOK(res1)) {
8567  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpCapabilityUnknow_write" "', argument " "1"" of type '" "libbgp::BgpCapabilityUnknow const *""'");
8568  }
8569  arg1 = reinterpret_cast< libbgp::BgpCapabilityUnknow * >(argp1);
8570  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
8571  if (!SWIG_IsOK(res2)) {
8572  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpCapabilityUnknow_write" "', argument " "2"" of type '" "uint8_t *""'");
8573  }
8574  arg2 = reinterpret_cast< uint8_t * >(argp2);
8575  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
8576  if (!SWIG_IsOK(ecode3)) {
8577  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpCapabilityUnknow_write" "', argument " "3"" of type '" "size_t""'");
8578  }
8579  arg3 = static_cast< size_t >(val3);
8580  result = ((libbgp::BgpCapabilityUnknow const *)arg1)->write(arg2,arg3);
8581  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
8582  return resultobj;
8583 fail:
8584  return NULL;
8585 }
8586 
8587 
8588 SWIGINTERN PyObject *BgpCapabilityUnknow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8589  PyObject *obj;
8590  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
8591  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpCapabilityUnknow, SWIG_NewClientData(obj));
8592  return SWIG_Py_Void();
8593 }
8594 
8595 SWIGINTERN PyObject *_wrap_BgpFilterRule_filter_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8596  PyObject *resultobj = 0;
8598  uint8_t arg2 ;
8599  void *argp1 = 0 ;
8600  int res1 = 0 ;
8601  unsigned char val2 ;
8602  int ecode2 = 0 ;
8603  PyObject * obj0 = 0 ;
8604  PyObject * obj1 = 0 ;
8605 
8606  if (!PyArg_ParseTuple(args,(char *)"OO:BgpFilterRule_filter_type_set",&obj0,&obj1)) SWIG_fail;
8607  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRule, 0 | 0 );
8608  if (!SWIG_IsOK(res1)) {
8609  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRule_filter_type_set" "', argument " "1"" of type '" "libbgp::BgpFilterRule *""'");
8610  }
8611  arg1 = reinterpret_cast< libbgp::BgpFilterRule * >(argp1);
8612  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
8613  if (!SWIG_IsOK(ecode2)) {
8614  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpFilterRule_filter_type_set" "', argument " "2"" of type '" "uint8_t""'");
8615  }
8616  arg2 = static_cast< uint8_t >(val2);
8617  if (arg1) (arg1)->filter_type = arg2;
8618  resultobj = SWIG_Py_Void();
8619  return resultobj;
8620 fail:
8621  return NULL;
8622 }
8623 
8624 
8625 SWIGINTERN PyObject *_wrap_BgpFilterRule_filter_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8626  PyObject *resultobj = 0;
8628  void *argp1 = 0 ;
8629  int res1 = 0 ;
8630  PyObject * obj0 = 0 ;
8631  uint8_t result;
8632 
8633  if (!PyArg_ParseTuple(args,(char *)"O:BgpFilterRule_filter_type_get",&obj0)) SWIG_fail;
8634  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRule, 0 | 0 );
8635  if (!SWIG_IsOK(res1)) {
8636  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRule_filter_type_get" "', argument " "1"" of type '" "libbgp::BgpFilterRule *""'");
8637  }
8638  arg1 = reinterpret_cast< libbgp::BgpFilterRule * >(argp1);
8639  result = (uint8_t) ((arg1)->filter_type);
8640  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
8641  return resultobj;
8642 fail:
8643  return NULL;
8644 }
8645 
8646 
8647 SWIGINTERN PyObject *_wrap_BgpFilterRule_match_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8648  PyObject *resultobj = 0;
8650  uint8_t arg2 ;
8651  void *argp1 = 0 ;
8652  int res1 = 0 ;
8653  unsigned char val2 ;
8654  int ecode2 = 0 ;
8655  PyObject * obj0 = 0 ;
8656  PyObject * obj1 = 0 ;
8657 
8658  if (!PyArg_ParseTuple(args,(char *)"OO:BgpFilterRule_match_type_set",&obj0,&obj1)) SWIG_fail;
8659  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRule, 0 | 0 );
8660  if (!SWIG_IsOK(res1)) {
8661  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRule_match_type_set" "', argument " "1"" of type '" "libbgp::BgpFilterRule *""'");
8662  }
8663  arg1 = reinterpret_cast< libbgp::BgpFilterRule * >(argp1);
8664  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
8665  if (!SWIG_IsOK(ecode2)) {
8666  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpFilterRule_match_type_set" "', argument " "2"" of type '" "uint8_t""'");
8667  }
8668  arg2 = static_cast< uint8_t >(val2);
8669  if (arg1) (arg1)->match_type = arg2;
8670  resultobj = SWIG_Py_Void();
8671  return resultobj;
8672 fail:
8673  return NULL;
8674 }
8675 
8676 
8677 SWIGINTERN PyObject *_wrap_BgpFilterRule_match_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8678  PyObject *resultobj = 0;
8680  void *argp1 = 0 ;
8681  int res1 = 0 ;
8682  PyObject * obj0 = 0 ;
8683  uint8_t result;
8684 
8685  if (!PyArg_ParseTuple(args,(char *)"O:BgpFilterRule_match_type_get",&obj0)) SWIG_fail;
8686  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRule, 0 | 0 );
8687  if (!SWIG_IsOK(res1)) {
8688  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRule_match_type_get" "', argument " "1"" of type '" "libbgp::BgpFilterRule *""'");
8689  }
8690  arg1 = reinterpret_cast< libbgp::BgpFilterRule * >(argp1);
8691  result = (uint8_t) ((arg1)->match_type);
8692  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
8693  return resultobj;
8694 fail:
8695  return NULL;
8696 }
8697 
8698 
8699 SWIGINTERN PyObject *_wrap_BgpFilterRule_op_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8700  PyObject *resultobj = 0;
8702  libbgp::BgpFilterOP arg2 ;
8703  void *argp1 = 0 ;
8704  int res1 = 0 ;
8705  int val2 ;
8706  int ecode2 = 0 ;
8707  PyObject * obj0 = 0 ;
8708  PyObject * obj1 = 0 ;
8709 
8710  if (!PyArg_ParseTuple(args,(char *)"OO:BgpFilterRule_op_set",&obj0,&obj1)) SWIG_fail;
8711  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRule, 0 | 0 );
8712  if (!SWIG_IsOK(res1)) {
8713  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRule_op_set" "', argument " "1"" of type '" "libbgp::BgpFilterRule *""'");
8714  }
8715  arg1 = reinterpret_cast< libbgp::BgpFilterRule * >(argp1);
8716  ecode2 = SWIG_AsVal_int(obj1, &val2);
8717  if (!SWIG_IsOK(ecode2)) {
8718  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpFilterRule_op_set" "', argument " "2"" of type '" "libbgp::BgpFilterOP""'");
8719  }
8720  arg2 = static_cast< libbgp::BgpFilterOP >(val2);
8721  if (arg1) (arg1)->op = arg2;
8722  resultobj = SWIG_Py_Void();
8723  return resultobj;
8724 fail:
8725  return NULL;
8726 }
8727 
8728 
8729 SWIGINTERN PyObject *_wrap_BgpFilterRule_op_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8730  PyObject *resultobj = 0;
8732  void *argp1 = 0 ;
8733  int res1 = 0 ;
8734  PyObject * obj0 = 0 ;
8735  libbgp::BgpFilterOP result;
8736 
8737  if (!PyArg_ParseTuple(args,(char *)"O:BgpFilterRule_op_get",&obj0)) SWIG_fail;
8738  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRule, 0 | 0 );
8739  if (!SWIG_IsOK(res1)) {
8740  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRule_op_get" "', argument " "1"" of type '" "libbgp::BgpFilterRule *""'");
8741  }
8742  arg1 = reinterpret_cast< libbgp::BgpFilterRule * >(argp1);
8743  result = (libbgp::BgpFilterOP) ((arg1)->op);
8744  resultobj = SWIG_From_int(static_cast< int >(result));
8745  return resultobj;
8746 fail:
8747  return NULL;
8748 }
8749 
8750 
8751 SWIGINTERN PyObject *_wrap_BgpFilterRule_apply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8752  PyObject *resultobj = 0;
8754  libbgp::Prefix *arg2 = 0 ;
8755  std::vector< std::shared_ptr< BgpPathAttrib > > *arg3 = 0 ;
8756  void *argp1 = 0 ;
8757  int res1 = 0 ;
8758  void *argp2 = 0 ;
8759  int res2 = 0 ;
8760  void *argp3 = 0 ;
8761  int res3 = 0 ;
8762  PyObject * obj0 = 0 ;
8763  PyObject * obj1 = 0 ;
8764  PyObject * obj2 = 0 ;
8765  libbgp::BgpFilterOP result;
8766 
8767  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpFilterRule_apply",&obj0,&obj1,&obj2)) SWIG_fail;
8768  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRule, 0 | 0 );
8769  if (!SWIG_IsOK(res1)) {
8770  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRule_apply" "', argument " "1"" of type '" "libbgp::BgpFilterRule *""'");
8771  }
8772  arg1 = reinterpret_cast< libbgp::BgpFilterRule * >(argp1);
8773  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
8774  if (!SWIG_IsOK(res2)) {
8775  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpFilterRule_apply" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
8776  }
8777  if (!argp2) {
8778  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpFilterRule_apply" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
8779  }
8780  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
8781  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t, 0 | 0);
8782  if (!SWIG_IsOK(res3)) {
8783  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpFilterRule_apply" "', argument " "3"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > > const &""'");
8784  }
8785  if (!argp3) {
8786  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpFilterRule_apply" "', argument " "3"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > > const &""'");
8787  }
8788  arg3 = reinterpret_cast< std::vector< std::shared_ptr< BgpPathAttrib > > * >(argp3);
8789  result = (libbgp::BgpFilterOP)(arg1)->apply((libbgp::Prefix const &)*arg2,(std::vector< std::shared_ptr< BgpPathAttrib > > const &)*arg3);
8790  resultobj = SWIG_From_int(static_cast< int >(result));
8791  return resultobj;
8792 fail:
8793  return NULL;
8794 }
8795 
8796 
8797 SWIGINTERN PyObject *_wrap_delete_BgpFilterRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8798  PyObject *resultobj = 0;
8800  void *argp1 = 0 ;
8801  int res1 = 0 ;
8802  PyObject * obj0 = 0 ;
8803 
8804  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpFilterRule",&obj0)) SWIG_fail;
8805  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRule, SWIG_POINTER_DISOWN | 0 );
8806  if (!SWIG_IsOK(res1)) {
8807  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpFilterRule" "', argument " "1"" of type '" "libbgp::BgpFilterRule *""'");
8808  }
8809  arg1 = reinterpret_cast< libbgp::BgpFilterRule * >(argp1);
8810  delete arg1;
8811  resultobj = SWIG_Py_Void();
8812  return resultobj;
8813 fail:
8814  return NULL;
8815 }
8816 
8817 
8818 SWIGINTERN PyObject *BgpFilterRule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8819  PyObject *obj;
8820  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
8821  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpFilterRule, SWIG_NewClientData(obj));
8822  return SWIG_Py_Void();
8823 }
8824 
8825 SWIGINTERN PyObject *_wrap_new_Prefix4RouteFilterRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8826  PyObject *resultobj = 0;
8828 
8829  if (!PyArg_ParseTuple(args,(char *)":new_Prefix4RouteFilterRule")) SWIG_fail;
8831  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t, SWIG_POINTER_NEW | 0 );
8832  return resultobj;
8833 fail:
8834  return NULL;
8835 }
8836 
8837 
8838 SWIGINTERN PyObject *_wrap_Prefix4RouteFilterRule_prefix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8839  PyObject *resultobj = 0;
8841  libbgp::Prefix4 *arg2 = (libbgp::Prefix4 *) 0 ;
8842  void *argp1 = 0 ;
8843  int res1 = 0 ;
8844  void *argp2 = 0 ;
8845  int res2 = 0 ;
8846  PyObject * obj0 = 0 ;
8847  PyObject * obj1 = 0 ;
8848 
8849  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix4RouteFilterRule_prefix_set",&obj0,&obj1)) SWIG_fail;
8850  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t, 0 | 0 );
8851  if (!SWIG_IsOK(res1)) {
8852  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4RouteFilterRule_prefix_set" "', argument " "1"" of type '" "libbgp::BgpFilterRuleRoute< libbgp::Prefix4 > *""'");
8853  }
8854  arg1 = reinterpret_cast< libbgp::BgpFilterRuleRoute< libbgp::Prefix4 > * >(argp1);
8855  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
8856  if (!SWIG_IsOK(res2)) {
8857  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix4RouteFilterRule_prefix_set" "', argument " "2"" of type '" "libbgp::Prefix4 *""'");
8858  }
8859  arg2 = reinterpret_cast< libbgp::Prefix4 * >(argp2);
8860  if (arg1) (arg1)->prefix = *arg2;
8861  resultobj = SWIG_Py_Void();
8862  return resultobj;
8863 fail:
8864  return NULL;
8865 }
8866 
8867 
8868 SWIGINTERN PyObject *_wrap_Prefix4RouteFilterRule_prefix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8869  PyObject *resultobj = 0;
8871  void *argp1 = 0 ;
8872  int res1 = 0 ;
8873  PyObject * obj0 = 0 ;
8874  libbgp::Prefix4 *result = 0 ;
8875 
8876  if (!PyArg_ParseTuple(args,(char *)"O:Prefix4RouteFilterRule_prefix_get",&obj0)) SWIG_fail;
8877  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t, 0 | 0 );
8878  if (!SWIG_IsOK(res1)) {
8879  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4RouteFilterRule_prefix_get" "', argument " "1"" of type '" "libbgp::BgpFilterRuleRoute< libbgp::Prefix4 > *""'");
8880  }
8881  arg1 = reinterpret_cast< libbgp::BgpFilterRuleRoute< libbgp::Prefix4 > * >(argp1);
8882  result = (libbgp::Prefix4 *)& ((arg1)->prefix);
8883  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
8884  return resultobj;
8885 fail:
8886  return NULL;
8887 }
8888 
8889 
8890 SWIGINTERN PyObject *_wrap_Prefix4RouteFilterRule_apply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8891  PyObject *resultobj = 0;
8893  libbgp::Prefix *arg2 = 0 ;
8894  std::vector< std::shared_ptr< BgpPathAttrib > > *arg3 = 0 ;
8895  void *argp1 = 0 ;
8896  int res1 = 0 ;
8897  void *argp2 = 0 ;
8898  int res2 = 0 ;
8899  void *argp3 = 0 ;
8900  int res3 = 0 ;
8901  PyObject * obj0 = 0 ;
8902  PyObject * obj1 = 0 ;
8903  PyObject * obj2 = 0 ;
8904  libbgp::BgpFilterOP result;
8905 
8906  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix4RouteFilterRule_apply",&obj0,&obj1,&obj2)) SWIG_fail;
8907  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t, 0 | 0 );
8908  if (!SWIG_IsOK(res1)) {
8909  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix4RouteFilterRule_apply" "', argument " "1"" of type '" "libbgp::BgpFilterRuleRoute< libbgp::Prefix4 > *""'");
8910  }
8911  arg1 = reinterpret_cast< libbgp::BgpFilterRuleRoute< libbgp::Prefix4 > * >(argp1);
8912  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
8913  if (!SWIG_IsOK(res2)) {
8914  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix4RouteFilterRule_apply" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
8915  }
8916  if (!argp2) {
8917  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix4RouteFilterRule_apply" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
8918  }
8919  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
8920  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t, 0 | 0);
8921  if (!SWIG_IsOK(res3)) {
8922  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Prefix4RouteFilterRule_apply" "', argument " "3"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > > const &""'");
8923  }
8924  if (!argp3) {
8925  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix4RouteFilterRule_apply" "', argument " "3"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > > const &""'");
8926  }
8927  arg3 = reinterpret_cast< std::vector< std::shared_ptr< BgpPathAttrib > > * >(argp3);
8928  result = (libbgp::BgpFilterOP)(arg1)->apply((libbgp::Prefix const &)*arg2,(std::vector< std::shared_ptr< BgpPathAttrib > > const &)*arg3);
8929  resultobj = SWIG_From_int(static_cast< int >(result));
8930  return resultobj;
8931 fail:
8932  return NULL;
8933 }
8934 
8935 
8936 SWIGINTERN PyObject *_wrap_delete_Prefix4RouteFilterRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8937  PyObject *resultobj = 0;
8939  void *argp1 = 0 ;
8940  int res1 = 0 ;
8941  PyObject * obj0 = 0 ;
8942 
8943  if (!PyArg_ParseTuple(args,(char *)"O:delete_Prefix4RouteFilterRule",&obj0)) SWIG_fail;
8944  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t, SWIG_POINTER_DISOWN | 0 );
8945  if (!SWIG_IsOK(res1)) {
8946  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Prefix4RouteFilterRule" "', argument " "1"" of type '" "libbgp::BgpFilterRuleRoute< libbgp::Prefix4 > *""'");
8947  }
8948  arg1 = reinterpret_cast< libbgp::BgpFilterRuleRoute< libbgp::Prefix4 > * >(argp1);
8949  delete arg1;
8950  resultobj = SWIG_Py_Void();
8951  return resultobj;
8952 fail:
8953  return NULL;
8954 }
8955 
8956 
8957 SWIGINTERN PyObject *Prefix4RouteFilterRule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8958  PyObject *obj;
8959  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
8960  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t, SWIG_NewClientData(obj));
8961  return SWIG_Py_Void();
8962 }
8963 
8964 SWIGINTERN PyObject *_wrap_new_Prefix6RouteFilterRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8965  PyObject *resultobj = 0;
8967 
8968  if (!PyArg_ParseTuple(args,(char *)":new_Prefix6RouteFilterRule")) SWIG_fail;
8970  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t, SWIG_POINTER_NEW | 0 );
8971  return resultobj;
8972 fail:
8973  return NULL;
8974 }
8975 
8976 
8977 SWIGINTERN PyObject *_wrap_Prefix6RouteFilterRule_prefix_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8978  PyObject *resultobj = 0;
8980  libbgp::Prefix6 *arg2 = (libbgp::Prefix6 *) 0 ;
8981  void *argp1 = 0 ;
8982  int res1 = 0 ;
8983  void *argp2 = 0 ;
8984  int res2 = 0 ;
8985  PyObject * obj0 = 0 ;
8986  PyObject * obj1 = 0 ;
8987 
8988  if (!PyArg_ParseTuple(args,(char *)"OO:Prefix6RouteFilterRule_prefix_set",&obj0,&obj1)) SWIG_fail;
8989  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t, 0 | 0 );
8990  if (!SWIG_IsOK(res1)) {
8991  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6RouteFilterRule_prefix_set" "', argument " "1"" of type '" "libbgp::BgpFilterRuleRoute< libbgp::Prefix6 > *""'");
8992  }
8993  arg1 = reinterpret_cast< libbgp::BgpFilterRuleRoute< libbgp::Prefix6 > * >(argp1);
8994  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
8995  if (!SWIG_IsOK(res2)) {
8996  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6RouteFilterRule_prefix_set" "', argument " "2"" of type '" "libbgp::Prefix6 *""'");
8997  }
8998  arg2 = reinterpret_cast< libbgp::Prefix6 * >(argp2);
8999  if (arg1) (arg1)->prefix = *arg2;
9000  resultobj = SWIG_Py_Void();
9001  return resultobj;
9002 fail:
9003  return NULL;
9004 }
9005 
9006 
9007 SWIGINTERN PyObject *_wrap_Prefix6RouteFilterRule_prefix_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9008  PyObject *resultobj = 0;
9010  void *argp1 = 0 ;
9011  int res1 = 0 ;
9012  PyObject * obj0 = 0 ;
9013  libbgp::Prefix6 *result = 0 ;
9014 
9015  if (!PyArg_ParseTuple(args,(char *)"O:Prefix6RouteFilterRule_prefix_get",&obj0)) SWIG_fail;
9016  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t, 0 | 0 );
9017  if (!SWIG_IsOK(res1)) {
9018  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6RouteFilterRule_prefix_get" "', argument " "1"" of type '" "libbgp::BgpFilterRuleRoute< libbgp::Prefix6 > *""'");
9019  }
9020  arg1 = reinterpret_cast< libbgp::BgpFilterRuleRoute< libbgp::Prefix6 > * >(argp1);
9021  result = (libbgp::Prefix6 *)& ((arg1)->prefix);
9022  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
9023  return resultobj;
9024 fail:
9025  return NULL;
9026 }
9027 
9028 
9029 SWIGINTERN PyObject *_wrap_Prefix6RouteFilterRule_apply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9030  PyObject *resultobj = 0;
9032  libbgp::Prefix *arg2 = 0 ;
9033  std::vector< std::shared_ptr< BgpPathAttrib > > *arg3 = 0 ;
9034  void *argp1 = 0 ;
9035  int res1 = 0 ;
9036  void *argp2 = 0 ;
9037  int res2 = 0 ;
9038  void *argp3 = 0 ;
9039  int res3 = 0 ;
9040  PyObject * obj0 = 0 ;
9041  PyObject * obj1 = 0 ;
9042  PyObject * obj2 = 0 ;
9043  libbgp::BgpFilterOP result;
9044 
9045  if (!PyArg_ParseTuple(args,(char *)"OOO:Prefix6RouteFilterRule_apply",&obj0,&obj1,&obj2)) SWIG_fail;
9046  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t, 0 | 0 );
9047  if (!SWIG_IsOK(res1)) {
9048  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Prefix6RouteFilterRule_apply" "', argument " "1"" of type '" "libbgp::BgpFilterRuleRoute< libbgp::Prefix6 > *""'");
9049  }
9050  arg1 = reinterpret_cast< libbgp::BgpFilterRuleRoute< libbgp::Prefix6 > * >(argp1);
9051  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
9052  if (!SWIG_IsOK(res2)) {
9053  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Prefix6RouteFilterRule_apply" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
9054  }
9055  if (!argp2) {
9056  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix6RouteFilterRule_apply" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
9057  }
9058  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
9059  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t, 0 | 0);
9060  if (!SWIG_IsOK(res3)) {
9061  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Prefix6RouteFilterRule_apply" "', argument " "3"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > > const &""'");
9062  }
9063  if (!argp3) {
9064  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Prefix6RouteFilterRule_apply" "', argument " "3"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > > const &""'");
9065  }
9066  arg3 = reinterpret_cast< std::vector< std::shared_ptr< BgpPathAttrib > > * >(argp3);
9067  result = (libbgp::BgpFilterOP)(arg1)->apply((libbgp::Prefix const &)*arg2,(std::vector< std::shared_ptr< BgpPathAttrib > > const &)*arg3);
9068  resultobj = SWIG_From_int(static_cast< int >(result));
9069  return resultobj;
9070 fail:
9071  return NULL;
9072 }
9073 
9074 
9075 SWIGINTERN PyObject *_wrap_delete_Prefix6RouteFilterRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9076  PyObject *resultobj = 0;
9078  void *argp1 = 0 ;
9079  int res1 = 0 ;
9080  PyObject * obj0 = 0 ;
9081 
9082  if (!PyArg_ParseTuple(args,(char *)"O:delete_Prefix6RouteFilterRule",&obj0)) SWIG_fail;
9083  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t, SWIG_POINTER_DISOWN | 0 );
9084  if (!SWIG_IsOK(res1)) {
9085  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Prefix6RouteFilterRule" "', argument " "1"" of type '" "libbgp::BgpFilterRuleRoute< libbgp::Prefix6 > *""'");
9086  }
9087  arg1 = reinterpret_cast< libbgp::BgpFilterRuleRoute< libbgp::Prefix6 > * >(argp1);
9088  delete arg1;
9089  resultobj = SWIG_Py_Void();
9090  return resultobj;
9091 fail:
9092  return NULL;
9093 }
9094 
9095 
9096 SWIGINTERN PyObject *Prefix6RouteFilterRule_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9097  PyObject *obj;
9098  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
9099  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t, SWIG_NewClientData(obj));
9100  return SWIG_Py_Void();
9101 }
9102 
9103 SWIGINTERN PyObject *_wrap_new_BgpFilterRuleRoute4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9104  PyObject *resultobj = 0;
9105  libbgp::BgpFilterOP arg1 ;
9107  libbgp::Prefix4 *arg3 = 0 ;
9108  int val1 ;
9109  int ecode1 = 0 ;
9110  int val2 ;
9111  int ecode2 = 0 ;
9112  void *argp3 = 0 ;
9113  int res3 = 0 ;
9114  PyObject * obj0 = 0 ;
9115  PyObject * obj1 = 0 ;
9116  PyObject * obj2 = 0 ;
9117  libbgp::BgpFilterRuleRoute4 *result = 0 ;
9118 
9119  if (!PyArg_ParseTuple(args,(char *)"OOO:new_BgpFilterRuleRoute4",&obj0,&obj1,&obj2)) SWIG_fail;
9120  ecode1 = SWIG_AsVal_int(obj0, &val1);
9121  if (!SWIG_IsOK(ecode1)) {
9122  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BgpFilterRuleRoute4" "', argument " "1"" of type '" "libbgp::BgpFilterOP""'");
9123  }
9124  arg1 = static_cast< libbgp::BgpFilterOP >(val1);
9125  ecode2 = SWIG_AsVal_int(obj1, &val2);
9126  if (!SWIG_IsOK(ecode2)) {
9127  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpFilterRuleRoute4" "', argument " "2"" of type '" "libbgp::BgpFilterRuleRouteMatchType""'");
9128  }
9129  arg2 = static_cast< libbgp::BgpFilterRuleRouteMatchType >(val2);
9130  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix4, 0 | 0);
9131  if (!SWIG_IsOK(res3)) {
9132  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BgpFilterRuleRoute4" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
9133  }
9134  if (!argp3) {
9135  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BgpFilterRuleRoute4" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
9136  }
9137  arg3 = reinterpret_cast< libbgp::Prefix4 * >(argp3);
9138  result = (libbgp::BgpFilterRuleRoute4 *)new libbgp::BgpFilterRuleRoute4(arg1,arg2,(libbgp::Prefix4 const &)*arg3);
9139  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpFilterRuleRoute4, SWIG_POINTER_NEW | 0 );
9140  return resultobj;
9141 fail:
9142  return NULL;
9143 }
9144 
9145 
9146 SWIGINTERN PyObject *_wrap_delete_BgpFilterRuleRoute4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9147  PyObject *resultobj = 0;
9149  void *argp1 = 0 ;
9150  int res1 = 0 ;
9151  PyObject * obj0 = 0 ;
9152 
9153  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpFilterRuleRoute4",&obj0)) SWIG_fail;
9154  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleRoute4, SWIG_POINTER_DISOWN | 0 );
9155  if (!SWIG_IsOK(res1)) {
9156  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpFilterRuleRoute4" "', argument " "1"" of type '" "libbgp::BgpFilterRuleRoute4 *""'");
9157  }
9158  arg1 = reinterpret_cast< libbgp::BgpFilterRuleRoute4 * >(argp1);
9159  delete arg1;
9160  resultobj = SWIG_Py_Void();
9161  return resultobj;
9162 fail:
9163  return NULL;
9164 }
9165 
9166 
9167 SWIGINTERN PyObject *BgpFilterRuleRoute4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9168  PyObject *obj;
9169  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
9170  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpFilterRuleRoute4, SWIG_NewClientData(obj));
9171  return SWIG_Py_Void();
9172 }
9173 
9174 SWIGINTERN PyObject *_wrap_new_BgpFilterRuleRoute6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9175  PyObject *resultobj = 0;
9176  libbgp::BgpFilterOP arg1 ;
9178  libbgp::Prefix6 *arg3 = 0 ;
9179  int val1 ;
9180  int ecode1 = 0 ;
9181  int val2 ;
9182  int ecode2 = 0 ;
9183  void *argp3 = 0 ;
9184  int res3 = 0 ;
9185  PyObject * obj0 = 0 ;
9186  PyObject * obj1 = 0 ;
9187  PyObject * obj2 = 0 ;
9188  libbgp::BgpFilterRuleRoute6 *result = 0 ;
9189 
9190  if (!PyArg_ParseTuple(args,(char *)"OOO:new_BgpFilterRuleRoute6",&obj0,&obj1,&obj2)) SWIG_fail;
9191  ecode1 = SWIG_AsVal_int(obj0, &val1);
9192  if (!SWIG_IsOK(ecode1)) {
9193  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BgpFilterRuleRoute6" "', argument " "1"" of type '" "libbgp::BgpFilterOP""'");
9194  }
9195  arg1 = static_cast< libbgp::BgpFilterOP >(val1);
9196  ecode2 = SWIG_AsVal_int(obj1, &val2);
9197  if (!SWIG_IsOK(ecode2)) {
9198  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpFilterRuleRoute6" "', argument " "2"" of type '" "libbgp::BgpFilterRuleRouteMatchType""'");
9199  }
9200  arg2 = static_cast< libbgp::BgpFilterRuleRouteMatchType >(val2);
9201  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix6, 0 | 0);
9202  if (!SWIG_IsOK(res3)) {
9203  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BgpFilterRuleRoute6" "', argument " "3"" of type '" "libbgp::Prefix6 const &""'");
9204  }
9205  if (!argp3) {
9206  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BgpFilterRuleRoute6" "', argument " "3"" of type '" "libbgp::Prefix6 const &""'");
9207  }
9208  arg3 = reinterpret_cast< libbgp::Prefix6 * >(argp3);
9209  result = (libbgp::BgpFilterRuleRoute6 *)new libbgp::BgpFilterRuleRoute6(arg1,arg2,(libbgp::Prefix6 const &)*arg3);
9210  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpFilterRuleRoute6, SWIG_POINTER_NEW | 0 );
9211  return resultobj;
9212 fail:
9213  return NULL;
9214 }
9215 
9216 
9217 SWIGINTERN PyObject *_wrap_delete_BgpFilterRuleRoute6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9218  PyObject *resultobj = 0;
9220  void *argp1 = 0 ;
9221  int res1 = 0 ;
9222  PyObject * obj0 = 0 ;
9223 
9224  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpFilterRuleRoute6",&obj0)) SWIG_fail;
9225  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleRoute6, SWIG_POINTER_DISOWN | 0 );
9226  if (!SWIG_IsOK(res1)) {
9227  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpFilterRuleRoute6" "', argument " "1"" of type '" "libbgp::BgpFilterRuleRoute6 *""'");
9228  }
9229  arg1 = reinterpret_cast< libbgp::BgpFilterRuleRoute6 * >(argp1);
9230  delete arg1;
9231  resultobj = SWIG_Py_Void();
9232  return resultobj;
9233 fail:
9234  return NULL;
9235 }
9236 
9237 
9238 SWIGINTERN PyObject *BgpFilterRuleRoute6_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9239  PyObject *obj;
9240  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
9241  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpFilterRuleRoute6, SWIG_NewClientData(obj));
9242  return SWIG_Py_Void();
9243 }
9244 
9245 SWIGINTERN PyObject *_wrap_new_BgpFilterRuleAsPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9246  PyObject *resultobj = 0;
9247  libbgp::BgpFilterOP arg1 ;
9249  uint32_t arg3 ;
9250  int val1 ;
9251  int ecode1 = 0 ;
9252  int val2 ;
9253  int ecode2 = 0 ;
9254  unsigned int val3 ;
9255  int ecode3 = 0 ;
9256  PyObject * obj0 = 0 ;
9257  PyObject * obj1 = 0 ;
9258  PyObject * obj2 = 0 ;
9259  libbgp::BgpFilterRuleAsPath *result = 0 ;
9260 
9261  if (!PyArg_ParseTuple(args,(char *)"OOO:new_BgpFilterRuleAsPath",&obj0,&obj1,&obj2)) SWIG_fail;
9262  ecode1 = SWIG_AsVal_int(obj0, &val1);
9263  if (!SWIG_IsOK(ecode1)) {
9264  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BgpFilterRuleAsPath" "', argument " "1"" of type '" "libbgp::BgpFilterOP""'");
9265  }
9266  arg1 = static_cast< libbgp::BgpFilterOP >(val1);
9267  ecode2 = SWIG_AsVal_int(obj1, &val2);
9268  if (!SWIG_IsOK(ecode2)) {
9269  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpFilterRuleAsPath" "', argument " "2"" of type '" "libbgp::BgpFilterRuleAsPathMatchType""'");
9270  }
9271  arg2 = static_cast< libbgp::BgpFilterRuleAsPathMatchType >(val2);
9272  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
9273  if (!SWIG_IsOK(ecode3)) {
9274  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BgpFilterRuleAsPath" "', argument " "3"" of type '" "uint32_t""'");
9275  }
9276  arg3 = static_cast< uint32_t >(val3);
9277  result = (libbgp::BgpFilterRuleAsPath *)new libbgp::BgpFilterRuleAsPath(arg1,arg2,arg3);
9278  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpFilterRuleAsPath, SWIG_POINTER_NEW | 0 );
9279  return resultobj;
9280 fail:
9281  return NULL;
9282 }
9283 
9284 
9285 SWIGINTERN PyObject *_wrap_BgpFilterRuleAsPath_asn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9286  PyObject *resultobj = 0;
9288  uint32_t arg2 ;
9289  void *argp1 = 0 ;
9290  int res1 = 0 ;
9291  unsigned int val2 ;
9292  int ecode2 = 0 ;
9293  PyObject * obj0 = 0 ;
9294  PyObject * obj1 = 0 ;
9295 
9296  if (!PyArg_ParseTuple(args,(char *)"OO:BgpFilterRuleAsPath_asn_set",&obj0,&obj1)) SWIG_fail;
9297  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleAsPath, 0 | 0 );
9298  if (!SWIG_IsOK(res1)) {
9299  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRuleAsPath_asn_set" "', argument " "1"" of type '" "libbgp::BgpFilterRuleAsPath *""'");
9300  }
9301  arg1 = reinterpret_cast< libbgp::BgpFilterRuleAsPath * >(argp1);
9302  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9303  if (!SWIG_IsOK(ecode2)) {
9304  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpFilterRuleAsPath_asn_set" "', argument " "2"" of type '" "uint32_t""'");
9305  }
9306  arg2 = static_cast< uint32_t >(val2);
9307  if (arg1) (arg1)->asn = arg2;
9308  resultobj = SWIG_Py_Void();
9309  return resultobj;
9310 fail:
9311  return NULL;
9312 }
9313 
9314 
9315 SWIGINTERN PyObject *_wrap_BgpFilterRuleAsPath_asn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9316  PyObject *resultobj = 0;
9318  void *argp1 = 0 ;
9319  int res1 = 0 ;
9320  PyObject * obj0 = 0 ;
9321  uint32_t result;
9322 
9323  if (!PyArg_ParseTuple(args,(char *)"O:BgpFilterRuleAsPath_asn_get",&obj0)) SWIG_fail;
9324  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleAsPath, 0 | 0 );
9325  if (!SWIG_IsOK(res1)) {
9326  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRuleAsPath_asn_get" "', argument " "1"" of type '" "libbgp::BgpFilterRuleAsPath *""'");
9327  }
9328  arg1 = reinterpret_cast< libbgp::BgpFilterRuleAsPath * >(argp1);
9329  result = (uint32_t) ((arg1)->asn);
9330  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
9331  return resultobj;
9332 fail:
9333  return NULL;
9334 }
9335 
9336 
9337 SWIGINTERN PyObject *_wrap_BgpFilterRuleAsPath_apply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9338  PyObject *resultobj = 0;
9340  libbgp::Prefix *arg2 = 0 ;
9341  std::vector< std::shared_ptr< BgpPathAttrib > > *arg3 = 0 ;
9342  void *argp1 = 0 ;
9343  int res1 = 0 ;
9344  void *argp2 = 0 ;
9345  int res2 = 0 ;
9346  void *argp3 = 0 ;
9347  int res3 = 0 ;
9348  PyObject * obj0 = 0 ;
9349  PyObject * obj1 = 0 ;
9350  PyObject * obj2 = 0 ;
9351  libbgp::BgpFilterOP result;
9352 
9353  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpFilterRuleAsPath_apply",&obj0,&obj1,&obj2)) SWIG_fail;
9354  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleAsPath, 0 | 0 );
9355  if (!SWIG_IsOK(res1)) {
9356  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRuleAsPath_apply" "', argument " "1"" of type '" "libbgp::BgpFilterRuleAsPath *""'");
9357  }
9358  arg1 = reinterpret_cast< libbgp::BgpFilterRuleAsPath * >(argp1);
9359  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
9360  if (!SWIG_IsOK(res2)) {
9361  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpFilterRuleAsPath_apply" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
9362  }
9363  if (!argp2) {
9364  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpFilterRuleAsPath_apply" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
9365  }
9366  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
9367  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t, 0 | 0);
9368  if (!SWIG_IsOK(res3)) {
9369  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpFilterRuleAsPath_apply" "', argument " "3"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > > const &""'");
9370  }
9371  if (!argp3) {
9372  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpFilterRuleAsPath_apply" "', argument " "3"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > > const &""'");
9373  }
9374  arg3 = reinterpret_cast< std::vector< std::shared_ptr< BgpPathAttrib > > * >(argp3);
9375  result = (libbgp::BgpFilterOP)(arg1)->apply((libbgp::Prefix const &)*arg2,(std::vector< std::shared_ptr< BgpPathAttrib > > const &)*arg3);
9376  resultobj = SWIG_From_int(static_cast< int >(result));
9377  return resultobj;
9378 fail:
9379  return NULL;
9380 }
9381 
9382 
9383 SWIGINTERN PyObject *_wrap_delete_BgpFilterRuleAsPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9384  PyObject *resultobj = 0;
9386  void *argp1 = 0 ;
9387  int res1 = 0 ;
9388  PyObject * obj0 = 0 ;
9389 
9390  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpFilterRuleAsPath",&obj0)) SWIG_fail;
9391  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleAsPath, SWIG_POINTER_DISOWN | 0 );
9392  if (!SWIG_IsOK(res1)) {
9393  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpFilterRuleAsPath" "', argument " "1"" of type '" "libbgp::BgpFilterRuleAsPath *""'");
9394  }
9395  arg1 = reinterpret_cast< libbgp::BgpFilterRuleAsPath * >(argp1);
9396  delete arg1;
9397  resultobj = SWIG_Py_Void();
9398  return resultobj;
9399 fail:
9400  return NULL;
9401 }
9402 
9403 
9404 SWIGINTERN PyObject *BgpFilterRuleAsPath_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9405  PyObject *obj;
9406  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
9407  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpFilterRuleAsPath, SWIG_NewClientData(obj));
9408  return SWIG_Py_Void();
9409 }
9410 
9411 SWIGINTERN PyObject *_wrap_new_BgpFilterRuleCommunity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9412  PyObject *resultobj = 0;
9413  libbgp::BgpFilterOP arg1 ;
9415  uint16_t arg3 ;
9416  uint16_t arg4 ;
9417  int val1 ;
9418  int ecode1 = 0 ;
9419  int val2 ;
9420  int ecode2 = 0 ;
9421  unsigned short val3 ;
9422  int ecode3 = 0 ;
9423  unsigned short val4 ;
9424  int ecode4 = 0 ;
9425  PyObject * obj0 = 0 ;
9426  PyObject * obj1 = 0 ;
9427  PyObject * obj2 = 0 ;
9428  PyObject * obj3 = 0 ;
9429  libbgp::BgpFilterRuleCommunity *result = 0 ;
9430 
9431  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_BgpFilterRuleCommunity",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9432  ecode1 = SWIG_AsVal_int(obj0, &val1);
9433  if (!SWIG_IsOK(ecode1)) {
9434  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BgpFilterRuleCommunity" "', argument " "1"" of type '" "libbgp::BgpFilterOP""'");
9435  }
9436  arg1 = static_cast< libbgp::BgpFilterOP >(val1);
9437  ecode2 = SWIG_AsVal_int(obj1, &val2);
9438  if (!SWIG_IsOK(ecode2)) {
9439  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpFilterRuleCommunity" "', argument " "2"" of type '" "libbgp::BgpFilterRuleCommunityMatchType""'");
9440  }
9441  arg2 = static_cast< libbgp::BgpFilterRuleCommunityMatchType >(val2);
9442  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
9443  if (!SWIG_IsOK(ecode3)) {
9444  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BgpFilterRuleCommunity" "', argument " "3"" of type '" "uint16_t""'");
9445  }
9446  arg3 = static_cast< uint16_t >(val3);
9447  ecode4 = SWIG_AsVal_unsigned_SS_short(obj3, &val4);
9448  if (!SWIG_IsOK(ecode4)) {
9449  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BgpFilterRuleCommunity" "', argument " "4"" of type '" "uint16_t""'");
9450  }
9451  arg4 = static_cast< uint16_t >(val4);
9452  result = (libbgp::BgpFilterRuleCommunity *)new libbgp::BgpFilterRuleCommunity(arg1,arg2,arg3,arg4);
9453  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpFilterRuleCommunity, SWIG_POINTER_NEW | 0 );
9454  return resultobj;
9455 fail:
9456  return NULL;
9457 }
9458 
9459 
9460 SWIGINTERN PyObject *_wrap_new_BgpFilterRuleCommunity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9461  PyObject *resultobj = 0;
9462  libbgp::BgpFilterOP arg1 ;
9464  uint32_t arg3 ;
9465  int val1 ;
9466  int ecode1 = 0 ;
9467  int val2 ;
9468  int ecode2 = 0 ;
9469  unsigned int val3 ;
9470  int ecode3 = 0 ;
9471  PyObject * obj0 = 0 ;
9472  PyObject * obj1 = 0 ;
9473  PyObject * obj2 = 0 ;
9474  libbgp::BgpFilterRuleCommunity *result = 0 ;
9475 
9476  if (!PyArg_ParseTuple(args,(char *)"OOO:new_BgpFilterRuleCommunity",&obj0,&obj1,&obj2)) SWIG_fail;
9477  ecode1 = SWIG_AsVal_int(obj0, &val1);
9478  if (!SWIG_IsOK(ecode1)) {
9479  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BgpFilterRuleCommunity" "', argument " "1"" of type '" "libbgp::BgpFilterOP""'");
9480  }
9481  arg1 = static_cast< libbgp::BgpFilterOP >(val1);
9482  ecode2 = SWIG_AsVal_int(obj1, &val2);
9483  if (!SWIG_IsOK(ecode2)) {
9484  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpFilterRuleCommunity" "', argument " "2"" of type '" "libbgp::BgpFilterRuleCommunityMatchType""'");
9485  }
9486  arg2 = static_cast< libbgp::BgpFilterRuleCommunityMatchType >(val2);
9487  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
9488  if (!SWIG_IsOK(ecode3)) {
9489  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BgpFilterRuleCommunity" "', argument " "3"" of type '" "uint32_t""'");
9490  }
9491  arg3 = static_cast< uint32_t >(val3);
9492  result = (libbgp::BgpFilterRuleCommunity *)new libbgp::BgpFilterRuleCommunity(arg1,arg2,arg3);
9493  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpFilterRuleCommunity, SWIG_POINTER_NEW | 0 );
9494  return resultobj;
9495 fail:
9496  return NULL;
9497 }
9498 
9499 
9500 SWIGINTERN PyObject *_wrap_new_BgpFilterRuleCommunity(PyObject *self, PyObject *args) {
9501  Py_ssize_t argc;
9502  PyObject *argv[5] = {
9503  0
9504  };
9505  Py_ssize_t ii;
9506 
9507  if (!PyTuple_Check(args)) SWIG_fail;
9508  argc = args ? PyObject_Length(args) : 0;
9509  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
9510  argv[ii] = PyTuple_GET_ITEM(args,ii);
9511  }
9512  if (argc == 3) {
9513  int _v;
9514  {
9515  int res = SWIG_AsVal_int(argv[0], NULL);
9516  _v = SWIG_CheckState(res);
9517  }
9518  if (_v) {
9519  {
9520  int res = SWIG_AsVal_int(argv[1], NULL);
9521  _v = SWIG_CheckState(res);
9522  }
9523  if (_v) {
9524  {
9525  int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
9526  _v = SWIG_CheckState(res);
9527  }
9528  if (_v) {
9529  return _wrap_new_BgpFilterRuleCommunity__SWIG_1(self, args);
9530  }
9531  }
9532  }
9533  }
9534  if (argc == 4) {
9535  int _v;
9536  {
9537  int res = SWIG_AsVal_int(argv[0], NULL);
9538  _v = SWIG_CheckState(res);
9539  }
9540  if (_v) {
9541  {
9542  int res = SWIG_AsVal_int(argv[1], NULL);
9543  _v = SWIG_CheckState(res);
9544  }
9545  if (_v) {
9546  {
9547  int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
9548  _v = SWIG_CheckState(res);
9549  }
9550  if (_v) {
9551  {
9552  int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
9553  _v = SWIG_CheckState(res);
9554  }
9555  if (_v) {
9556  return _wrap_new_BgpFilterRuleCommunity__SWIG_0(self, args);
9557  }
9558  }
9559  }
9560  }
9561  }
9562 
9563 fail:
9564  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BgpFilterRuleCommunity'.\n"
9565  " Possible C/C++ prototypes are:\n"
9566  " libbgp::BgpFilterRuleCommunity::BgpFilterRuleCommunity(libbgp::BgpFilterOP,libbgp::BgpFilterRuleCommunityMatchType,uint16_t,uint16_t)\n"
9567  " libbgp::BgpFilterRuleCommunity::BgpFilterRuleCommunity(libbgp::BgpFilterOP,libbgp::BgpFilterRuleCommunityMatchType,uint32_t)\n");
9568  return 0;
9569 }
9570 
9571 
9572 SWIGINTERN PyObject *_wrap_BgpFilterRuleCommunity_community_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9573  PyObject *resultobj = 0;
9575  uint32_t arg2 ;
9576  void *argp1 = 0 ;
9577  int res1 = 0 ;
9578  unsigned int val2 ;
9579  int ecode2 = 0 ;
9580  PyObject * obj0 = 0 ;
9581  PyObject * obj1 = 0 ;
9582 
9583  if (!PyArg_ParseTuple(args,(char *)"OO:BgpFilterRuleCommunity_community_set",&obj0,&obj1)) SWIG_fail;
9584  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleCommunity, 0 | 0 );
9585  if (!SWIG_IsOK(res1)) {
9586  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRuleCommunity_community_set" "', argument " "1"" of type '" "libbgp::BgpFilterRuleCommunity *""'");
9587  }
9588  arg1 = reinterpret_cast< libbgp::BgpFilterRuleCommunity * >(argp1);
9589  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9590  if (!SWIG_IsOK(ecode2)) {
9591  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpFilterRuleCommunity_community_set" "', argument " "2"" of type '" "uint32_t""'");
9592  }
9593  arg2 = static_cast< uint32_t >(val2);
9594  if (arg1) (arg1)->community = arg2;
9595  resultobj = SWIG_Py_Void();
9596  return resultobj;
9597 fail:
9598  return NULL;
9599 }
9600 
9601 
9602 SWIGINTERN PyObject *_wrap_BgpFilterRuleCommunity_community_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9603  PyObject *resultobj = 0;
9605  void *argp1 = 0 ;
9606  int res1 = 0 ;
9607  PyObject * obj0 = 0 ;
9608  uint32_t result;
9609 
9610  if (!PyArg_ParseTuple(args,(char *)"O:BgpFilterRuleCommunity_community_get",&obj0)) SWIG_fail;
9611  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleCommunity, 0 | 0 );
9612  if (!SWIG_IsOK(res1)) {
9613  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRuleCommunity_community_get" "', argument " "1"" of type '" "libbgp::BgpFilterRuleCommunity *""'");
9614  }
9615  arg1 = reinterpret_cast< libbgp::BgpFilterRuleCommunity * >(argp1);
9616  result = (uint32_t) ((arg1)->community);
9617  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
9618  return resultobj;
9619 fail:
9620  return NULL;
9621 }
9622 
9623 
9624 SWIGINTERN PyObject *_wrap_BgpFilterRuleCommunity_apply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9625  PyObject *resultobj = 0;
9627  libbgp::Prefix *arg2 = 0 ;
9628  std::vector< std::shared_ptr< BgpPathAttrib > > *arg3 = 0 ;
9629  void *argp1 = 0 ;
9630  int res1 = 0 ;
9631  void *argp2 = 0 ;
9632  int res2 = 0 ;
9633  void *argp3 = 0 ;
9634  int res3 = 0 ;
9635  PyObject * obj0 = 0 ;
9636  PyObject * obj1 = 0 ;
9637  PyObject * obj2 = 0 ;
9638  libbgp::BgpFilterOP result;
9639 
9640  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpFilterRuleCommunity_apply",&obj0,&obj1,&obj2)) SWIG_fail;
9641  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleCommunity, 0 | 0 );
9642  if (!SWIG_IsOK(res1)) {
9643  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRuleCommunity_apply" "', argument " "1"" of type '" "libbgp::BgpFilterRuleCommunity *""'");
9644  }
9645  arg1 = reinterpret_cast< libbgp::BgpFilterRuleCommunity * >(argp1);
9646  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
9647  if (!SWIG_IsOK(res2)) {
9648  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpFilterRuleCommunity_apply" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
9649  }
9650  if (!argp2) {
9651  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpFilterRuleCommunity_apply" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
9652  }
9653  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
9654  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t, 0 | 0);
9655  if (!SWIG_IsOK(res3)) {
9656  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpFilterRuleCommunity_apply" "', argument " "3"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > > const &""'");
9657  }
9658  if (!argp3) {
9659  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpFilterRuleCommunity_apply" "', argument " "3"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > > const &""'");
9660  }
9661  arg3 = reinterpret_cast< std::vector< std::shared_ptr< BgpPathAttrib > > * >(argp3);
9662  result = (libbgp::BgpFilterOP)(arg1)->apply((libbgp::Prefix const &)*arg2,(std::vector< std::shared_ptr< BgpPathAttrib > > const &)*arg3);
9663  resultobj = SWIG_From_int(static_cast< int >(result));
9664  return resultobj;
9665 fail:
9666  return NULL;
9667 }
9668 
9669 
9670 SWIGINTERN PyObject *_wrap_delete_BgpFilterRuleCommunity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9671  PyObject *resultobj = 0;
9673  void *argp1 = 0 ;
9674  int res1 = 0 ;
9675  PyObject * obj0 = 0 ;
9676 
9677  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpFilterRuleCommunity",&obj0)) SWIG_fail;
9678  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRuleCommunity, SWIG_POINTER_DISOWN | 0 );
9679  if (!SWIG_IsOK(res1)) {
9680  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpFilterRuleCommunity" "', argument " "1"" of type '" "libbgp::BgpFilterRuleCommunity *""'");
9681  }
9682  arg1 = reinterpret_cast< libbgp::BgpFilterRuleCommunity * >(argp1);
9683  delete arg1;
9684  resultobj = SWIG_Py_Void();
9685  return resultobj;
9686 fail:
9687  return NULL;
9688 }
9689 
9690 
9691 SWIGINTERN PyObject *BgpFilterRuleCommunity_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9692  PyObject *obj;
9693  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
9694  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpFilterRuleCommunity, SWIG_NewClientData(obj));
9695  return SWIG_Py_Void();
9696 }
9697 
9698 SWIGINTERN PyObject *_wrap_new_BgpFilterRules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9699  PyObject *resultobj = 0;
9700  libbgp::BgpFilterRules *result = 0 ;
9701 
9702  if (!PyArg_ParseTuple(args,(char *)":new_BgpFilterRules")) SWIG_fail;
9704  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpFilterRules, SWIG_POINTER_NEW | 0 );
9705  return resultobj;
9706 fail:
9707  return NULL;
9708 }
9709 
9710 
9711 SWIGINTERN PyObject *_wrap_new_BgpFilterRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9712  PyObject *resultobj = 0;
9713  libbgp::BgpFilterOP arg1 ;
9714  int val1 ;
9715  int ecode1 = 0 ;
9716  PyObject * obj0 = 0 ;
9717  libbgp::BgpFilterRules *result = 0 ;
9718 
9719  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpFilterRules",&obj0)) SWIG_fail;
9720  ecode1 = SWIG_AsVal_int(obj0, &val1);
9721  if (!SWIG_IsOK(ecode1)) {
9722  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BgpFilterRules" "', argument " "1"" of type '" "libbgp::BgpFilterOP""'");
9723  }
9724  arg1 = static_cast< libbgp::BgpFilterOP >(val1);
9725  result = (libbgp::BgpFilterRules *)new libbgp::BgpFilterRules(arg1);
9726  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpFilterRules, SWIG_POINTER_NEW | 0 );
9727  return resultobj;
9728 fail:
9729  return NULL;
9730 }
9731 
9732 
9733 SWIGINTERN PyObject *_wrap_new_BgpFilterRules(PyObject *self, PyObject *args) {
9734  Py_ssize_t argc;
9735  PyObject *argv[2] = {
9736  0
9737  };
9738  Py_ssize_t ii;
9739 
9740  if (!PyTuple_Check(args)) SWIG_fail;
9741  argc = args ? PyObject_Length(args) : 0;
9742  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
9743  argv[ii] = PyTuple_GET_ITEM(args,ii);
9744  }
9745  if (argc == 0) {
9746  return _wrap_new_BgpFilterRules__SWIG_0(self, args);
9747  }
9748  if (argc == 1) {
9749  int _v;
9750  {
9751  int res = SWIG_AsVal_int(argv[0], NULL);
9752  _v = SWIG_CheckState(res);
9753  }
9754  if (_v) {
9755  return _wrap_new_BgpFilterRules__SWIG_1(self, args);
9756  }
9757  }
9758 
9759 fail:
9760  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BgpFilterRules'.\n"
9761  " Possible C/C++ prototypes are:\n"
9762  " libbgp::BgpFilterRules::BgpFilterRules()\n"
9763  " libbgp::BgpFilterRules::BgpFilterRules(libbgp::BgpFilterOP)\n");
9764  return 0;
9765 }
9766 
9767 
9768 SWIGINTERN PyObject *_wrap_BgpFilterRules_appendAsPathRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9769  PyObject *resultobj = 0;
9771  libbgp::BgpFilterRule *arg2 = 0 ;
9772  void *argp1 = 0 ;
9773  int res1 = 0 ;
9774  void *argp2 = 0 ;
9775  int res2 = 0 ;
9776  PyObject * obj0 = 0 ;
9777  PyObject * obj1 = 0 ;
9778 
9779  if (!PyArg_ParseTuple(args,(char *)"OO:BgpFilterRules_appendAsPathRule",&obj0,&obj1)) SWIG_fail;
9780  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRules, 0 | 0 );
9781  if (!SWIG_IsOK(res1)) {
9782  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRules_appendAsPathRule" "', argument " "1"" of type '" "libbgp::BgpFilterRules *""'");
9783  }
9784  arg1 = reinterpret_cast< libbgp::BgpFilterRules * >(argp1);
9785  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__BgpFilterRule, 0 | 0);
9786  if (!SWIG_IsOK(res2)) {
9787  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpFilterRules_appendAsPathRule" "', argument " "2"" of type '" "libbgp::BgpFilterRule const &""'");
9788  }
9789  if (!argp2) {
9790  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpFilterRules_appendAsPathRule" "', argument " "2"" of type '" "libbgp::BgpFilterRule const &""'");
9791  }
9792  arg2 = reinterpret_cast< libbgp::BgpFilterRule * >(argp2);
9793  (arg1)->SWIGTEMPLATEDISAMBIGUATOR append< libbgp::BgpFilterRuleAsPath >((libbgp::BgpFilterRule const &)*arg2);
9794  resultobj = SWIG_Py_Void();
9795  return resultobj;
9796 fail:
9797  return NULL;
9798 }
9799 
9800 
9801 SWIGINTERN PyObject *_wrap_BgpFilterRules_appendCommunityRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9802  PyObject *resultobj = 0;
9804  libbgp::BgpFilterRule *arg2 = 0 ;
9805  void *argp1 = 0 ;
9806  int res1 = 0 ;
9807  void *argp2 = 0 ;
9808  int res2 = 0 ;
9809  PyObject * obj0 = 0 ;
9810  PyObject * obj1 = 0 ;
9811 
9812  if (!PyArg_ParseTuple(args,(char *)"OO:BgpFilterRules_appendCommunityRule",&obj0,&obj1)) SWIG_fail;
9813  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRules, 0 | 0 );
9814  if (!SWIG_IsOK(res1)) {
9815  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRules_appendCommunityRule" "', argument " "1"" of type '" "libbgp::BgpFilterRules *""'");
9816  }
9817  arg1 = reinterpret_cast< libbgp::BgpFilterRules * >(argp1);
9818  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__BgpFilterRule, 0 | 0);
9819  if (!SWIG_IsOK(res2)) {
9820  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpFilterRules_appendCommunityRule" "', argument " "2"" of type '" "libbgp::BgpFilterRule const &""'");
9821  }
9822  if (!argp2) {
9823  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpFilterRules_appendCommunityRule" "', argument " "2"" of type '" "libbgp::BgpFilterRule const &""'");
9824  }
9825  arg2 = reinterpret_cast< libbgp::BgpFilterRule * >(argp2);
9826  (arg1)->SWIGTEMPLATEDISAMBIGUATOR append< libbgp::BgpFilterRuleCommunity >((libbgp::BgpFilterRule const &)*arg2);
9827  resultobj = SWIG_Py_Void();
9828  return resultobj;
9829 fail:
9830  return NULL;
9831 }
9832 
9833 
9834 SWIGINTERN PyObject *_wrap_BgpFilterRules_appendRoute4Rule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9835  PyObject *resultobj = 0;
9837  libbgp::BgpFilterRule *arg2 = 0 ;
9838  void *argp1 = 0 ;
9839  int res1 = 0 ;
9840  void *argp2 = 0 ;
9841  int res2 = 0 ;
9842  PyObject * obj0 = 0 ;
9843  PyObject * obj1 = 0 ;
9844 
9845  if (!PyArg_ParseTuple(args,(char *)"OO:BgpFilterRules_appendRoute4Rule",&obj0,&obj1)) SWIG_fail;
9846  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRules, 0 | 0 );
9847  if (!SWIG_IsOK(res1)) {
9848  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRules_appendRoute4Rule" "', argument " "1"" of type '" "libbgp::BgpFilterRules *""'");
9849  }
9850  arg1 = reinterpret_cast< libbgp::BgpFilterRules * >(argp1);
9851  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__BgpFilterRule, 0 | 0);
9852  if (!SWIG_IsOK(res2)) {
9853  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpFilterRules_appendRoute4Rule" "', argument " "2"" of type '" "libbgp::BgpFilterRule const &""'");
9854  }
9855  if (!argp2) {
9856  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpFilterRules_appendRoute4Rule" "', argument " "2"" of type '" "libbgp::BgpFilterRule const &""'");
9857  }
9858  arg2 = reinterpret_cast< libbgp::BgpFilterRule * >(argp2);
9859  (arg1)->SWIGTEMPLATEDISAMBIGUATOR append< libbgp::BgpFilterRuleRoute4 >((libbgp::BgpFilterRule const &)*arg2);
9860  resultobj = SWIG_Py_Void();
9861  return resultobj;
9862 fail:
9863  return NULL;
9864 }
9865 
9866 
9867 SWIGINTERN PyObject *_wrap_BgpFilterRules_appendRoute6Rule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9868  PyObject *resultobj = 0;
9870  libbgp::BgpFilterRule *arg2 = 0 ;
9871  void *argp1 = 0 ;
9872  int res1 = 0 ;
9873  void *argp2 = 0 ;
9874  int res2 = 0 ;
9875  PyObject * obj0 = 0 ;
9876  PyObject * obj1 = 0 ;
9877 
9878  if (!PyArg_ParseTuple(args,(char *)"OO:BgpFilterRules_appendRoute6Rule",&obj0,&obj1)) SWIG_fail;
9879  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRules, 0 | 0 );
9880  if (!SWIG_IsOK(res1)) {
9881  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRules_appendRoute6Rule" "', argument " "1"" of type '" "libbgp::BgpFilterRules *""'");
9882  }
9883  arg1 = reinterpret_cast< libbgp::BgpFilterRules * >(argp1);
9884  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__BgpFilterRule, 0 | 0);
9885  if (!SWIG_IsOK(res2)) {
9886  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpFilterRules_appendRoute6Rule" "', argument " "2"" of type '" "libbgp::BgpFilterRule const &""'");
9887  }
9888  if (!argp2) {
9889  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpFilterRules_appendRoute6Rule" "', argument " "2"" of type '" "libbgp::BgpFilterRule const &""'");
9890  }
9891  arg2 = reinterpret_cast< libbgp::BgpFilterRule * >(argp2);
9892  (arg1)->SWIGTEMPLATEDISAMBIGUATOR append< libbgp::BgpFilterRuleRoute6 >((libbgp::BgpFilterRule const &)*arg2);
9893  resultobj = SWIG_Py_Void();
9894  return resultobj;
9895 fail:
9896  return NULL;
9897 }
9898 
9899 
9900 SWIGINTERN PyObject *_wrap_BgpFilterRules_apply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9901  PyObject *resultobj = 0;
9903  libbgp::Prefix *arg2 = 0 ;
9904  std::vector< std::shared_ptr< BgpPathAttrib > > *arg3 = 0 ;
9905  void *argp1 = 0 ;
9906  int res1 = 0 ;
9907  void *argp2 = 0 ;
9908  int res2 = 0 ;
9909  void *argp3 = 0 ;
9910  int res3 = 0 ;
9911  PyObject * obj0 = 0 ;
9912  PyObject * obj1 = 0 ;
9913  PyObject * obj2 = 0 ;
9914  libbgp::BgpFilterOP result;
9915 
9916  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpFilterRules_apply",&obj0,&obj1,&obj2)) SWIG_fail;
9917  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRules, 0 | 0 );
9918  if (!SWIG_IsOK(res1)) {
9919  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFilterRules_apply" "', argument " "1"" of type '" "libbgp::BgpFilterRules *""'");
9920  }
9921  arg1 = reinterpret_cast< libbgp::BgpFilterRules * >(argp1);
9922  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix, 0 | 0);
9923  if (!SWIG_IsOK(res2)) {
9924  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpFilterRules_apply" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
9925  }
9926  if (!argp2) {
9927  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpFilterRules_apply" "', argument " "2"" of type '" "libbgp::Prefix const &""'");
9928  }
9929  arg2 = reinterpret_cast< libbgp::Prefix * >(argp2);
9930  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t, 0 | 0);
9931  if (!SWIG_IsOK(res3)) {
9932  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpFilterRules_apply" "', argument " "3"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > > const &""'");
9933  }
9934  if (!argp3) {
9935  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpFilterRules_apply" "', argument " "3"" of type '" "std::vector< std::shared_ptr< BgpPathAttrib > > const &""'");
9936  }
9937  arg3 = reinterpret_cast< std::vector< std::shared_ptr< BgpPathAttrib > > * >(argp3);
9938  result = (libbgp::BgpFilterOP)(arg1)->apply((libbgp::Prefix const &)*arg2,(std::vector< std::shared_ptr< BgpPathAttrib > > const &)*arg3);
9939  resultobj = SWIG_From_int(static_cast< int >(result));
9940  return resultobj;
9941 fail:
9942  return NULL;
9943 }
9944 
9945 
9946 SWIGINTERN PyObject *_wrap_delete_BgpFilterRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9947  PyObject *resultobj = 0;
9949  void *argp1 = 0 ;
9950  int res1 = 0 ;
9951  PyObject * obj0 = 0 ;
9952 
9953  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpFilterRules",&obj0)) SWIG_fail;
9954  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFilterRules, SWIG_POINTER_DISOWN | 0 );
9955  if (!SWIG_IsOK(res1)) {
9956  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpFilterRules" "', argument " "1"" of type '" "libbgp::BgpFilterRules *""'");
9957  }
9958  arg1 = reinterpret_cast< libbgp::BgpFilterRules * >(argp1);
9959  delete arg1;
9960  resultobj = SWIG_Py_Void();
9961  return resultobj;
9962 fail:
9963  return NULL;
9964 }
9965 
9966 
9967 SWIGINTERN PyObject *BgpFilterRules_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9968  PyObject *obj;
9969  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
9970  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpFilterRules, SWIG_NewClientData(obj));
9971  return SWIG_Py_Void();
9972 }
9973 
9974 SWIGINTERN PyObject *_wrap_new_BgpConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9975  PyObject *resultobj = 0;
9976  libbgp::BgpConfig *result = 0 ;
9977 
9978  if (!PyArg_ParseTuple(args,(char *)":new_BgpConfig")) SWIG_fail;
9979  result = (libbgp::BgpConfig *)new libbgp::BgpConfig();
9980  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpConfig, SWIG_POINTER_NEW | 0 );
9981  return resultobj;
9982 fail:
9983  return NULL;
9984 }
9985 
9986 
9987 SWIGINTERN PyObject *_wrap_BgpConfig_in_filters4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9988  PyObject *resultobj = 0;
9989  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
9991  void *argp1 = 0 ;
9992  int res1 = 0 ;
9993  void *argp2 = 0 ;
9994  int res2 = 0 ;
9995  PyObject * obj0 = 0 ;
9996  PyObject * obj1 = 0 ;
9997 
9998  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_in_filters4_set",&obj0,&obj1)) SWIG_fail;
9999  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10000  if (!SWIG_IsOK(res1)) {
10001  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_in_filters4_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10002  }
10003  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10004  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpFilterRules, 0 | 0 );
10005  if (!SWIG_IsOK(res2)) {
10006  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpConfig_in_filters4_set" "', argument " "2"" of type '" "libbgp::BgpFilterRules *""'");
10007  }
10008  arg2 = reinterpret_cast< libbgp::BgpFilterRules * >(argp2);
10009  if (arg1) (arg1)->in_filters4 = *arg2;
10010  resultobj = SWIG_Py_Void();
10011  return resultobj;
10012 fail:
10013  return NULL;
10014 }
10015 
10016 
10017 SWIGINTERN PyObject *_wrap_BgpConfig_in_filters4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10018  PyObject *resultobj = 0;
10019  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10020  void *argp1 = 0 ;
10021  int res1 = 0 ;
10022  PyObject * obj0 = 0 ;
10023  libbgp::BgpFilterRules *result = 0 ;
10024 
10025  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_in_filters4_get",&obj0)) SWIG_fail;
10026  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10027  if (!SWIG_IsOK(res1)) {
10028  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_in_filters4_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10029  }
10030  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10031  result = (libbgp::BgpFilterRules *)& ((arg1)->in_filters4);
10032  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpFilterRules, 0 | 0 );
10033  return resultobj;
10034 fail:
10035  return NULL;
10036 }
10037 
10038 
10039 SWIGINTERN PyObject *_wrap_BgpConfig_out_filters4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10040  PyObject *resultobj = 0;
10041  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10043  void *argp1 = 0 ;
10044  int res1 = 0 ;
10045  void *argp2 = 0 ;
10046  int res2 = 0 ;
10047  PyObject * obj0 = 0 ;
10048  PyObject * obj1 = 0 ;
10049 
10050  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_out_filters4_set",&obj0,&obj1)) SWIG_fail;
10051  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10052  if (!SWIG_IsOK(res1)) {
10053  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_out_filters4_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10054  }
10055  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10056  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpFilterRules, 0 | 0 );
10057  if (!SWIG_IsOK(res2)) {
10058  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpConfig_out_filters4_set" "', argument " "2"" of type '" "libbgp::BgpFilterRules *""'");
10059  }
10060  arg2 = reinterpret_cast< libbgp::BgpFilterRules * >(argp2);
10061  if (arg1) (arg1)->out_filters4 = *arg2;
10062  resultobj = SWIG_Py_Void();
10063  return resultobj;
10064 fail:
10065  return NULL;
10066 }
10067 
10068 
10069 SWIGINTERN PyObject *_wrap_BgpConfig_out_filters4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10070  PyObject *resultobj = 0;
10071  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10072  void *argp1 = 0 ;
10073  int res1 = 0 ;
10074  PyObject * obj0 = 0 ;
10075  libbgp::BgpFilterRules *result = 0 ;
10076 
10077  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_out_filters4_get",&obj0)) SWIG_fail;
10078  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10079  if (!SWIG_IsOK(res1)) {
10080  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_out_filters4_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10081  }
10082  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10083  result = (libbgp::BgpFilterRules *)& ((arg1)->out_filters4);
10084  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpFilterRules, 0 | 0 );
10085  return resultobj;
10086 fail:
10087  return NULL;
10088 }
10089 
10090 
10091 SWIGINTERN PyObject *_wrap_BgpConfig_in_filters6_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10092  PyObject *resultobj = 0;
10093  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10095  void *argp1 = 0 ;
10096  int res1 = 0 ;
10097  void *argp2 = 0 ;
10098  int res2 = 0 ;
10099  PyObject * obj0 = 0 ;
10100  PyObject * obj1 = 0 ;
10101 
10102  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_in_filters6_set",&obj0,&obj1)) SWIG_fail;
10103  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10104  if (!SWIG_IsOK(res1)) {
10105  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_in_filters6_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10106  }
10107  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10108  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpFilterRules, 0 | 0 );
10109  if (!SWIG_IsOK(res2)) {
10110  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpConfig_in_filters6_set" "', argument " "2"" of type '" "libbgp::BgpFilterRules *""'");
10111  }
10112  arg2 = reinterpret_cast< libbgp::BgpFilterRules * >(argp2);
10113  if (arg1) (arg1)->in_filters6 = *arg2;
10114  resultobj = SWIG_Py_Void();
10115  return resultobj;
10116 fail:
10117  return NULL;
10118 }
10119 
10120 
10121 SWIGINTERN PyObject *_wrap_BgpConfig_in_filters6_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10122  PyObject *resultobj = 0;
10123  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10124  void *argp1 = 0 ;
10125  int res1 = 0 ;
10126  PyObject * obj0 = 0 ;
10127  libbgp::BgpFilterRules *result = 0 ;
10128 
10129  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_in_filters6_get",&obj0)) SWIG_fail;
10130  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10131  if (!SWIG_IsOK(res1)) {
10132  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_in_filters6_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10133  }
10134  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10135  result = (libbgp::BgpFilterRules *)& ((arg1)->in_filters6);
10136  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpFilterRules, 0 | 0 );
10137  return resultobj;
10138 fail:
10139  return NULL;
10140 }
10141 
10142 
10143 SWIGINTERN PyObject *_wrap_BgpConfig_out_filters6_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10144  PyObject *resultobj = 0;
10145  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10147  void *argp1 = 0 ;
10148  int res1 = 0 ;
10149  void *argp2 = 0 ;
10150  int res2 = 0 ;
10151  PyObject * obj0 = 0 ;
10152  PyObject * obj1 = 0 ;
10153 
10154  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_out_filters6_set",&obj0,&obj1)) SWIG_fail;
10155  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10156  if (!SWIG_IsOK(res1)) {
10157  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_out_filters6_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10158  }
10159  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10160  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpFilterRules, 0 | 0 );
10161  if (!SWIG_IsOK(res2)) {
10162  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpConfig_out_filters6_set" "', argument " "2"" of type '" "libbgp::BgpFilterRules *""'");
10163  }
10164  arg2 = reinterpret_cast< libbgp::BgpFilterRules * >(argp2);
10165  if (arg1) (arg1)->out_filters6 = *arg2;
10166  resultobj = SWIG_Py_Void();
10167  return resultobj;
10168 fail:
10169  return NULL;
10170 }
10171 
10172 
10173 SWIGINTERN PyObject *_wrap_BgpConfig_out_filters6_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10174  PyObject *resultobj = 0;
10175  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10176  void *argp1 = 0 ;
10177  int res1 = 0 ;
10178  PyObject * obj0 = 0 ;
10179  libbgp::BgpFilterRules *result = 0 ;
10180 
10181  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_out_filters6_get",&obj0)) SWIG_fail;
10182  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10183  if (!SWIG_IsOK(res1)) {
10184  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_out_filters6_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10185  }
10186  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10187  result = (libbgp::BgpFilterRules *)& ((arg1)->out_filters6);
10188  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpFilterRules, 0 | 0 );
10189  return resultobj;
10190 fail:
10191  return NULL;
10192 }
10193 
10194 
10195 SWIGINTERN PyObject *_wrap_BgpConfig_out_handler_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10196  PyObject *resultobj = 0;
10197  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10198  BgpOutHandler *arg2 = (BgpOutHandler *) 0 ;
10199  void *argp1 = 0 ;
10200  int res1 = 0 ;
10201  void *argp2 = 0 ;
10202  int res2 = 0 ;
10203  PyObject * obj0 = 0 ;
10204  PyObject * obj1 = 0 ;
10205 
10206  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_out_handler_set",&obj0,&obj1)) SWIG_fail;
10207  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10208  if (!SWIG_IsOK(res1)) {
10209  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_out_handler_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10210  }
10211  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10212  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_BgpOutHandler, SWIG_POINTER_DISOWN | 0 );
10213  if (!SWIG_IsOK(res2)) {
10214  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpConfig_out_handler_set" "', argument " "2"" of type '" "BgpOutHandler *""'");
10215  }
10216  arg2 = reinterpret_cast< BgpOutHandler * >(argp2);
10217  if (arg1) (arg1)->out_handler = arg2;
10218  resultobj = SWIG_Py_Void();
10219  return resultobj;
10220 fail:
10221  return NULL;
10222 }
10223 
10224 
10225 SWIGINTERN PyObject *_wrap_BgpConfig_out_handler_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10226  PyObject *resultobj = 0;
10227  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10228  void *argp1 = 0 ;
10229  int res1 = 0 ;
10230  PyObject * obj0 = 0 ;
10231  BgpOutHandler *result = 0 ;
10232 
10233  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_out_handler_get",&obj0)) SWIG_fail;
10234  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10235  if (!SWIG_IsOK(res1)) {
10236  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_out_handler_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10237  }
10238  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10239  result = (BgpOutHandler *) ((arg1)->out_handler);
10240  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BgpOutHandler, 0 | 0 );
10241  return resultobj;
10242 fail:
10243  return NULL;
10244 }
10245 
10246 
10247 SWIGINTERN PyObject *_wrap_BgpConfig_log_handler_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10248  PyObject *resultobj = 0;
10249  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10251  void *argp1 = 0 ;
10252  int res1 = 0 ;
10253  void *argp2 = 0 ;
10254  int res2 = 0 ;
10255  PyObject * obj0 = 0 ;
10256  PyObject * obj1 = 0 ;
10257 
10258  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_log_handler_set",&obj0,&obj1)) SWIG_fail;
10259  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10260  if (!SWIG_IsOK(res1)) {
10261  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_log_handler_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10262  }
10263  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10264  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, SWIG_POINTER_DISOWN | 0 );
10265  if (!SWIG_IsOK(res2)) {
10266  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpConfig_log_handler_set" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
10267  }
10268  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
10269  if (arg1) (arg1)->log_handler = arg2;
10270  resultobj = SWIG_Py_Void();
10271  return resultobj;
10272 fail:
10273  return NULL;
10274 }
10275 
10276 
10277 SWIGINTERN PyObject *_wrap_BgpConfig_log_handler_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10278  PyObject *resultobj = 0;
10279  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10280  void *argp1 = 0 ;
10281  int res1 = 0 ;
10282  PyObject * obj0 = 0 ;
10283  libbgp::BgpLogHandler *result = 0 ;
10284 
10285  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_log_handler_get",&obj0)) SWIG_fail;
10286  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10287  if (!SWIG_IsOK(res1)) {
10288  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_log_handler_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10289  }
10290  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10291  result = (libbgp::BgpLogHandler *) ((arg1)->log_handler);
10292  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
10293  return resultobj;
10294 fail:
10295  return NULL;
10296 }
10297 
10298 
10299 SWIGINTERN PyObject *_wrap_BgpConfig_rib4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10300  PyObject *resultobj = 0;
10301  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10302  BgpRib4 *arg2 = (BgpRib4 *) 0 ;
10303  void *argp1 = 0 ;
10304  int res1 = 0 ;
10305  void *argp2 = 0 ;
10306  int res2 = 0 ;
10307  PyObject * obj0 = 0 ;
10308  PyObject * obj1 = 0 ;
10309 
10310  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_rib4_set",&obj0,&obj1)) SWIG_fail;
10311  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10312  if (!SWIG_IsOK(res1)) {
10313  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_rib4_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10314  }
10315  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10316  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_BgpRib4, SWIG_POINTER_DISOWN | 0 );
10317  if (!SWIG_IsOK(res2)) {
10318  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpConfig_rib4_set" "', argument " "2"" of type '" "BgpRib4 *""'");
10319  }
10320  arg2 = reinterpret_cast< BgpRib4 * >(argp2);
10321  if (arg1) (arg1)->rib4 = arg2;
10322  resultobj = SWIG_Py_Void();
10323  return resultobj;
10324 fail:
10325  return NULL;
10326 }
10327 
10328 
10329 SWIGINTERN PyObject *_wrap_BgpConfig_rib4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10330  PyObject *resultobj = 0;
10331  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10332  void *argp1 = 0 ;
10333  int res1 = 0 ;
10334  PyObject * obj0 = 0 ;
10335  BgpRib4 *result = 0 ;
10336 
10337  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_rib4_get",&obj0)) SWIG_fail;
10338  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10339  if (!SWIG_IsOK(res1)) {
10340  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_rib4_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10341  }
10342  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10343  result = (BgpRib4 *) ((arg1)->rib4);
10344  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BgpRib4, 0 | 0 );
10345  return resultobj;
10346 fail:
10347  return NULL;
10348 }
10349 
10350 
10351 SWIGINTERN PyObject *_wrap_BgpConfig_rib6_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10352  PyObject *resultobj = 0;
10353  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10354  BgpRib6 *arg2 = (BgpRib6 *) 0 ;
10355  void *argp1 = 0 ;
10356  int res1 = 0 ;
10357  void *argp2 = 0 ;
10358  int res2 = 0 ;
10359  PyObject * obj0 = 0 ;
10360  PyObject * obj1 = 0 ;
10361 
10362  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_rib6_set",&obj0,&obj1)) SWIG_fail;
10363  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10364  if (!SWIG_IsOK(res1)) {
10365  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_rib6_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10366  }
10367  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10368  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_BgpRib6, SWIG_POINTER_DISOWN | 0 );
10369  if (!SWIG_IsOK(res2)) {
10370  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpConfig_rib6_set" "', argument " "2"" of type '" "BgpRib6 *""'");
10371  }
10372  arg2 = reinterpret_cast< BgpRib6 * >(argp2);
10373  if (arg1) (arg1)->rib6 = arg2;
10374  resultobj = SWIG_Py_Void();
10375  return resultobj;
10376 fail:
10377  return NULL;
10378 }
10379 
10380 
10381 SWIGINTERN PyObject *_wrap_BgpConfig_rib6_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10382  PyObject *resultobj = 0;
10383  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10384  void *argp1 = 0 ;
10385  int res1 = 0 ;
10386  PyObject * obj0 = 0 ;
10387  BgpRib6 *result = 0 ;
10388 
10389  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_rib6_get",&obj0)) SWIG_fail;
10390  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10391  if (!SWIG_IsOK(res1)) {
10392  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_rib6_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10393  }
10394  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10395  result = (BgpRib6 *) ((arg1)->rib6);
10396  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BgpRib6, 0 | 0 );
10397  return resultobj;
10398 fail:
10399  return NULL;
10400 }
10401 
10402 
10403 SWIGINTERN PyObject *_wrap_BgpConfig_rev_bus_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10404  PyObject *resultobj = 0;
10405  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10407  void *argp1 = 0 ;
10408  int res1 = 0 ;
10409  void *argp2 = 0 ;
10410  int res2 = 0 ;
10411  PyObject * obj0 = 0 ;
10412  PyObject * obj1 = 0 ;
10413 
10414  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_rev_bus_set",&obj0,&obj1)) SWIG_fail;
10415  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10416  if (!SWIG_IsOK(res1)) {
10417  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_rev_bus_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10418  }
10419  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10420  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__RouteEventBus, SWIG_POINTER_DISOWN | 0 );
10421  if (!SWIG_IsOK(res2)) {
10422  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpConfig_rev_bus_set" "', argument " "2"" of type '" "libbgp::RouteEventBus *""'");
10423  }
10424  arg2 = reinterpret_cast< libbgp::RouteEventBus * >(argp2);
10425  if (arg1) (arg1)->rev_bus = arg2;
10426  resultobj = SWIG_Py_Void();
10427  return resultobj;
10428 fail:
10429  return NULL;
10430 }
10431 
10432 
10433 SWIGINTERN PyObject *_wrap_BgpConfig_rev_bus_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10434  PyObject *resultobj = 0;
10435  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10436  void *argp1 = 0 ;
10437  int res1 = 0 ;
10438  PyObject * obj0 = 0 ;
10439  libbgp::RouteEventBus *result = 0 ;
10440 
10441  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_rev_bus_get",&obj0)) SWIG_fail;
10442  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10443  if (!SWIG_IsOK(res1)) {
10444  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_rev_bus_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10445  }
10446  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10447  result = (libbgp::RouteEventBus *) ((arg1)->rev_bus);
10448  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__RouteEventBus, 0 | 0 );
10449  return resultobj;
10450 fail:
10451  return NULL;
10452 }
10453 
10454 
10455 SWIGINTERN PyObject *_wrap_BgpConfig_no_collision_detection_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10456  PyObject *resultobj = 0;
10457  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10458  bool arg2 ;
10459  void *argp1 = 0 ;
10460  int res1 = 0 ;
10461  bool val2 ;
10462  int ecode2 = 0 ;
10463  PyObject * obj0 = 0 ;
10464  PyObject * obj1 = 0 ;
10465 
10466  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_no_collision_detection_set",&obj0,&obj1)) SWIG_fail;
10467  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10468  if (!SWIG_IsOK(res1)) {
10469  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_no_collision_detection_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10470  }
10471  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10472  ecode2 = SWIG_AsVal_bool(obj1, &val2);
10473  if (!SWIG_IsOK(ecode2)) {
10474  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_no_collision_detection_set" "', argument " "2"" of type '" "bool""'");
10475  }
10476  arg2 = static_cast< bool >(val2);
10477  if (arg1) (arg1)->no_collision_detection = arg2;
10478  resultobj = SWIG_Py_Void();
10479  return resultobj;
10480 fail:
10481  return NULL;
10482 }
10483 
10484 
10485 SWIGINTERN PyObject *_wrap_BgpConfig_no_collision_detection_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10486  PyObject *resultobj = 0;
10487  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10488  void *argp1 = 0 ;
10489  int res1 = 0 ;
10490  PyObject * obj0 = 0 ;
10491  bool result;
10492 
10493  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_no_collision_detection_get",&obj0)) SWIG_fail;
10494  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10495  if (!SWIG_IsOK(res1)) {
10496  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_no_collision_detection_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10497  }
10498  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10499  result = (bool) ((arg1)->no_collision_detection);
10500  resultobj = SWIG_From_bool(static_cast< bool >(result));
10501  return resultobj;
10502 fail:
10503  return NULL;
10504 }
10505 
10506 
10507 SWIGINTERN PyObject *_wrap_BgpConfig_use_4b_asn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10508  PyObject *resultobj = 0;
10509  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10510  bool arg2 ;
10511  void *argp1 = 0 ;
10512  int res1 = 0 ;
10513  bool val2 ;
10514  int ecode2 = 0 ;
10515  PyObject * obj0 = 0 ;
10516  PyObject * obj1 = 0 ;
10517 
10518  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_use_4b_asn_set",&obj0,&obj1)) SWIG_fail;
10519  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10520  if (!SWIG_IsOK(res1)) {
10521  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_use_4b_asn_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10522  }
10523  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10524  ecode2 = SWIG_AsVal_bool(obj1, &val2);
10525  if (!SWIG_IsOK(ecode2)) {
10526  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_use_4b_asn_set" "', argument " "2"" of type '" "bool""'");
10527  }
10528  arg2 = static_cast< bool >(val2);
10529  if (arg1) (arg1)->use_4b_asn = arg2;
10530  resultobj = SWIG_Py_Void();
10531  return resultobj;
10532 fail:
10533  return NULL;
10534 }
10535 
10536 
10537 SWIGINTERN PyObject *_wrap_BgpConfig_use_4b_asn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10538  PyObject *resultobj = 0;
10539  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10540  void *argp1 = 0 ;
10541  int res1 = 0 ;
10542  PyObject * obj0 = 0 ;
10543  bool result;
10544 
10545  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_use_4b_asn_get",&obj0)) SWIG_fail;
10546  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10547  if (!SWIG_IsOK(res1)) {
10548  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_use_4b_asn_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10549  }
10550  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10551  result = (bool) ((arg1)->use_4b_asn);
10552  resultobj = SWIG_From_bool(static_cast< bool >(result));
10553  return resultobj;
10554 fail:
10555  return NULL;
10556 }
10557 
10558 
10559 SWIGINTERN PyObject *_wrap_BgpConfig_mp_bgp_ipv4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10560  PyObject *resultobj = 0;
10561  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10562  bool arg2 ;
10563  void *argp1 = 0 ;
10564  int res1 = 0 ;
10565  bool val2 ;
10566  int ecode2 = 0 ;
10567  PyObject * obj0 = 0 ;
10568  PyObject * obj1 = 0 ;
10569 
10570  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_mp_bgp_ipv4_set",&obj0,&obj1)) SWIG_fail;
10571  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10572  if (!SWIG_IsOK(res1)) {
10573  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_mp_bgp_ipv4_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10574  }
10575  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10576  ecode2 = SWIG_AsVal_bool(obj1, &val2);
10577  if (!SWIG_IsOK(ecode2)) {
10578  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_mp_bgp_ipv4_set" "', argument " "2"" of type '" "bool""'");
10579  }
10580  arg2 = static_cast< bool >(val2);
10581  if (arg1) (arg1)->mp_bgp_ipv4 = arg2;
10582  resultobj = SWIG_Py_Void();
10583  return resultobj;
10584 fail:
10585  return NULL;
10586 }
10587 
10588 
10589 SWIGINTERN PyObject *_wrap_BgpConfig_mp_bgp_ipv4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10590  PyObject *resultobj = 0;
10591  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10592  void *argp1 = 0 ;
10593  int res1 = 0 ;
10594  PyObject * obj0 = 0 ;
10595  bool result;
10596 
10597  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_mp_bgp_ipv4_get",&obj0)) SWIG_fail;
10598  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10599  if (!SWIG_IsOK(res1)) {
10600  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_mp_bgp_ipv4_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10601  }
10602  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10603  result = (bool) ((arg1)->mp_bgp_ipv4);
10604  resultobj = SWIG_From_bool(static_cast< bool >(result));
10605  return resultobj;
10606 fail:
10607  return NULL;
10608 }
10609 
10610 
10611 SWIGINTERN PyObject *_wrap_BgpConfig_mp_bgp_ipv6_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10612  PyObject *resultobj = 0;
10613  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10614  bool arg2 ;
10615  void *argp1 = 0 ;
10616  int res1 = 0 ;
10617  bool val2 ;
10618  int ecode2 = 0 ;
10619  PyObject * obj0 = 0 ;
10620  PyObject * obj1 = 0 ;
10621 
10622  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_mp_bgp_ipv6_set",&obj0,&obj1)) SWIG_fail;
10623  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10624  if (!SWIG_IsOK(res1)) {
10625  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_mp_bgp_ipv6_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10626  }
10627  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10628  ecode2 = SWIG_AsVal_bool(obj1, &val2);
10629  if (!SWIG_IsOK(ecode2)) {
10630  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_mp_bgp_ipv6_set" "', argument " "2"" of type '" "bool""'");
10631  }
10632  arg2 = static_cast< bool >(val2);
10633  if (arg1) (arg1)->mp_bgp_ipv6 = arg2;
10634  resultobj = SWIG_Py_Void();
10635  return resultobj;
10636 fail:
10637  return NULL;
10638 }
10639 
10640 
10641 SWIGINTERN PyObject *_wrap_BgpConfig_mp_bgp_ipv6_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10642  PyObject *resultobj = 0;
10643  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10644  void *argp1 = 0 ;
10645  int res1 = 0 ;
10646  PyObject * obj0 = 0 ;
10647  bool result;
10648 
10649  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_mp_bgp_ipv6_get",&obj0)) SWIG_fail;
10650  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10651  if (!SWIG_IsOK(res1)) {
10652  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_mp_bgp_ipv6_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10653  }
10654  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10655  result = (bool) ((arg1)->mp_bgp_ipv6);
10656  resultobj = SWIG_From_bool(static_cast< bool >(result));
10657  return resultobj;
10658 fail:
10659  return NULL;
10660 }
10661 
10662 
10663 SWIGINTERN PyObject *_wrap_BgpConfig_asn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10664  PyObject *resultobj = 0;
10665  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10666  uint32_t arg2 ;
10667  void *argp1 = 0 ;
10668  int res1 = 0 ;
10669  unsigned int val2 ;
10670  int ecode2 = 0 ;
10671  PyObject * obj0 = 0 ;
10672  PyObject * obj1 = 0 ;
10673 
10674  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_asn_set",&obj0,&obj1)) SWIG_fail;
10675  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10676  if (!SWIG_IsOK(res1)) {
10677  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_asn_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10678  }
10679  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10680  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10681  if (!SWIG_IsOK(ecode2)) {
10682  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_asn_set" "', argument " "2"" of type '" "uint32_t""'");
10683  }
10684  arg2 = static_cast< uint32_t >(val2);
10685  if (arg1) (arg1)->asn = arg2;
10686  resultobj = SWIG_Py_Void();
10687  return resultobj;
10688 fail:
10689  return NULL;
10690 }
10691 
10692 
10693 SWIGINTERN PyObject *_wrap_BgpConfig_asn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10694  PyObject *resultobj = 0;
10695  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10696  void *argp1 = 0 ;
10697  int res1 = 0 ;
10698  PyObject * obj0 = 0 ;
10699  uint32_t result;
10700 
10701  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_asn_get",&obj0)) SWIG_fail;
10702  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10703  if (!SWIG_IsOK(res1)) {
10704  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_asn_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10705  }
10706  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10707  result = (uint32_t) ((arg1)->asn);
10708  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
10709  return resultobj;
10710 fail:
10711  return NULL;
10712 }
10713 
10714 
10715 SWIGINTERN PyObject *_wrap_BgpConfig_peer_asn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10716  PyObject *resultobj = 0;
10717  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10718  uint32_t arg2 ;
10719  void *argp1 = 0 ;
10720  int res1 = 0 ;
10721  unsigned int val2 ;
10722  int ecode2 = 0 ;
10723  PyObject * obj0 = 0 ;
10724  PyObject * obj1 = 0 ;
10725 
10726  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_peer_asn_set",&obj0,&obj1)) SWIG_fail;
10727  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10728  if (!SWIG_IsOK(res1)) {
10729  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_peer_asn_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10730  }
10731  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10732  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10733  if (!SWIG_IsOK(ecode2)) {
10734  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_peer_asn_set" "', argument " "2"" of type '" "uint32_t""'");
10735  }
10736  arg2 = static_cast< uint32_t >(val2);
10737  if (arg1) (arg1)->peer_asn = arg2;
10738  resultobj = SWIG_Py_Void();
10739  return resultobj;
10740 fail:
10741  return NULL;
10742 }
10743 
10744 
10745 SWIGINTERN PyObject *_wrap_BgpConfig_peer_asn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10746  PyObject *resultobj = 0;
10747  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10748  void *argp1 = 0 ;
10749  int res1 = 0 ;
10750  PyObject * obj0 = 0 ;
10751  uint32_t result;
10752 
10753  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_peer_asn_get",&obj0)) SWIG_fail;
10754  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10755  if (!SWIG_IsOK(res1)) {
10756  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_peer_asn_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10757  }
10758  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10759  result = (uint32_t) ((arg1)->peer_asn);
10760  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
10761  return resultobj;
10762 fail:
10763  return NULL;
10764 }
10765 
10766 
10767 SWIGINTERN PyObject *_wrap_BgpConfig_router_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10768  PyObject *resultobj = 0;
10769  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10770  uint32_t arg2 ;
10771  void *argp1 = 0 ;
10772  int res1 = 0 ;
10773  unsigned int val2 ;
10774  int ecode2 = 0 ;
10775  PyObject * obj0 = 0 ;
10776  PyObject * obj1 = 0 ;
10777 
10778  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_router_id_set",&obj0,&obj1)) SWIG_fail;
10779  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10780  if (!SWIG_IsOK(res1)) {
10781  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_router_id_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10782  }
10783  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10784  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10785  if (!SWIG_IsOK(ecode2)) {
10786  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_router_id_set" "', argument " "2"" of type '" "uint32_t""'");
10787  }
10788  arg2 = static_cast< uint32_t >(val2);
10789  if (arg1) (arg1)->router_id = arg2;
10790  resultobj = SWIG_Py_Void();
10791  return resultobj;
10792 fail:
10793  return NULL;
10794 }
10795 
10796 
10797 SWIGINTERN PyObject *_wrap_BgpConfig_router_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10798  PyObject *resultobj = 0;
10799  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10800  void *argp1 = 0 ;
10801  int res1 = 0 ;
10802  PyObject * obj0 = 0 ;
10803  uint32_t result;
10804 
10805  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_router_id_get",&obj0)) SWIG_fail;
10806  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10807  if (!SWIG_IsOK(res1)) {
10808  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_router_id_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10809  }
10810  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10811  result = (uint32_t) ((arg1)->router_id);
10812  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
10813  return resultobj;
10814 fail:
10815  return NULL;
10816 }
10817 
10818 
10819 SWIGINTERN PyObject *_wrap_BgpConfig_peering_lan4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10820  PyObject *resultobj = 0;
10821  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10822  libbgp::Prefix4 *arg2 = (libbgp::Prefix4 *) 0 ;
10823  void *argp1 = 0 ;
10824  int res1 = 0 ;
10825  void *argp2 = 0 ;
10826  int res2 = 0 ;
10827  PyObject * obj0 = 0 ;
10828  PyObject * obj1 = 0 ;
10829 
10830  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_peering_lan4_set",&obj0,&obj1)) SWIG_fail;
10831  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10832  if (!SWIG_IsOK(res1)) {
10833  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_peering_lan4_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10834  }
10835  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10836  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
10837  if (!SWIG_IsOK(res2)) {
10838  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpConfig_peering_lan4_set" "', argument " "2"" of type '" "libbgp::Prefix4 *""'");
10839  }
10840  arg2 = reinterpret_cast< libbgp::Prefix4 * >(argp2);
10841  if (arg1) (arg1)->peering_lan4 = *arg2;
10842  resultobj = SWIG_Py_Void();
10843  return resultobj;
10844 fail:
10845  return NULL;
10846 }
10847 
10848 
10849 SWIGINTERN PyObject *_wrap_BgpConfig_peering_lan4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10850  PyObject *resultobj = 0;
10851  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10852  void *argp1 = 0 ;
10853  int res1 = 0 ;
10854  PyObject * obj0 = 0 ;
10855  libbgp::Prefix4 *result = 0 ;
10856 
10857  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_peering_lan4_get",&obj0)) SWIG_fail;
10858  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10859  if (!SWIG_IsOK(res1)) {
10860  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_peering_lan4_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10861  }
10862  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10863  result = (libbgp::Prefix4 *)& ((arg1)->peering_lan4);
10864  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
10865  return resultobj;
10866 fail:
10867  return NULL;
10868 }
10869 
10870 
10871 SWIGINTERN PyObject *_wrap_BgpConfig_peering_lan6_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10872  PyObject *resultobj = 0;
10873  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10874  libbgp::Prefix6 *arg2 = (libbgp::Prefix6 *) 0 ;
10875  void *argp1 = 0 ;
10876  int res1 = 0 ;
10877  void *argp2 = 0 ;
10878  int res2 = 0 ;
10879  PyObject * obj0 = 0 ;
10880  PyObject * obj1 = 0 ;
10881 
10882  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_peering_lan6_set",&obj0,&obj1)) SWIG_fail;
10883  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10884  if (!SWIG_IsOK(res1)) {
10885  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_peering_lan6_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10886  }
10887  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10888  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
10889  if (!SWIG_IsOK(res2)) {
10890  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpConfig_peering_lan6_set" "', argument " "2"" of type '" "libbgp::Prefix6 *""'");
10891  }
10892  arg2 = reinterpret_cast< libbgp::Prefix6 * >(argp2);
10893  if (arg1) (arg1)->peering_lan6 = *arg2;
10894  resultobj = SWIG_Py_Void();
10895  return resultobj;
10896 fail:
10897  return NULL;
10898 }
10899 
10900 
10901 SWIGINTERN PyObject *_wrap_BgpConfig_peering_lan6_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10902  PyObject *resultobj = 0;
10903  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10904  void *argp1 = 0 ;
10905  int res1 = 0 ;
10906  PyObject * obj0 = 0 ;
10907  libbgp::Prefix6 *result = 0 ;
10908 
10909  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_peering_lan6_get",&obj0)) SWIG_fail;
10910  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10911  if (!SWIG_IsOK(res1)) {
10912  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_peering_lan6_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10913  }
10914  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10915  result = (libbgp::Prefix6 *)& ((arg1)->peering_lan6);
10916  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
10917  return resultobj;
10918 fail:
10919  return NULL;
10920 }
10921 
10922 
10923 SWIGINTERN PyObject *_wrap_BgpConfig_no_nexthop_check4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10924  PyObject *resultobj = 0;
10925  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10926  bool arg2 ;
10927  void *argp1 = 0 ;
10928  int res1 = 0 ;
10929  bool val2 ;
10930  int ecode2 = 0 ;
10931  PyObject * obj0 = 0 ;
10932  PyObject * obj1 = 0 ;
10933 
10934  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_no_nexthop_check4_set",&obj0,&obj1)) SWIG_fail;
10935  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10936  if (!SWIG_IsOK(res1)) {
10937  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_no_nexthop_check4_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10938  }
10939  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10940  ecode2 = SWIG_AsVal_bool(obj1, &val2);
10941  if (!SWIG_IsOK(ecode2)) {
10942  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_no_nexthop_check4_set" "', argument " "2"" of type '" "bool""'");
10943  }
10944  arg2 = static_cast< bool >(val2);
10945  if (arg1) (arg1)->no_nexthop_check4 = arg2;
10946  resultobj = SWIG_Py_Void();
10947  return resultobj;
10948 fail:
10949  return NULL;
10950 }
10951 
10952 
10953 SWIGINTERN PyObject *_wrap_BgpConfig_no_nexthop_check4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10954  PyObject *resultobj = 0;
10955  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10956  void *argp1 = 0 ;
10957  int res1 = 0 ;
10958  PyObject * obj0 = 0 ;
10959  bool result;
10960 
10961  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_no_nexthop_check4_get",&obj0)) SWIG_fail;
10962  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10963  if (!SWIG_IsOK(res1)) {
10964  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_no_nexthop_check4_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10965  }
10966  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10967  result = (bool) ((arg1)->no_nexthop_check4);
10968  resultobj = SWIG_From_bool(static_cast< bool >(result));
10969  return resultobj;
10970 fail:
10971  return NULL;
10972 }
10973 
10974 
10975 SWIGINTERN PyObject *_wrap_BgpConfig_default_nexthop4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10976  PyObject *resultobj = 0;
10977  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
10978  uint32_t arg2 ;
10979  void *argp1 = 0 ;
10980  int res1 = 0 ;
10981  unsigned int val2 ;
10982  int ecode2 = 0 ;
10983  PyObject * obj0 = 0 ;
10984  PyObject * obj1 = 0 ;
10985 
10986  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_default_nexthop4_set",&obj0,&obj1)) SWIG_fail;
10987  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
10988  if (!SWIG_IsOK(res1)) {
10989  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_default_nexthop4_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
10990  }
10991  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
10992  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10993  if (!SWIG_IsOK(ecode2)) {
10994  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_default_nexthop4_set" "', argument " "2"" of type '" "uint32_t""'");
10995  }
10996  arg2 = static_cast< uint32_t >(val2);
10997  if (arg1) (arg1)->default_nexthop4 = arg2;
10998  resultobj = SWIG_Py_Void();
10999  return resultobj;
11000 fail:
11001  return NULL;
11002 }
11003 
11004 
11005 SWIGINTERN PyObject *_wrap_BgpConfig_default_nexthop4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11006  PyObject *resultobj = 0;
11007  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11008  void *argp1 = 0 ;
11009  int res1 = 0 ;
11010  PyObject * obj0 = 0 ;
11011  uint32_t result;
11012 
11013  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_default_nexthop4_get",&obj0)) SWIG_fail;
11014  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11015  if (!SWIG_IsOK(res1)) {
11016  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_default_nexthop4_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11017  }
11018  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11019  result = (uint32_t) ((arg1)->default_nexthop4);
11020  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
11021  return resultobj;
11022 fail:
11023  return NULL;
11024 }
11025 
11026 
11027 SWIGINTERN PyObject *_wrap_BgpConfig_forced_default_nexthop4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11028  PyObject *resultobj = 0;
11029  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11030  bool arg2 ;
11031  void *argp1 = 0 ;
11032  int res1 = 0 ;
11033  bool val2 ;
11034  int ecode2 = 0 ;
11035  PyObject * obj0 = 0 ;
11036  PyObject * obj1 = 0 ;
11037 
11038  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_forced_default_nexthop4_set",&obj0,&obj1)) SWIG_fail;
11039  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11040  if (!SWIG_IsOK(res1)) {
11041  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_forced_default_nexthop4_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11042  }
11043  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11044  ecode2 = SWIG_AsVal_bool(obj1, &val2);
11045  if (!SWIG_IsOK(ecode2)) {
11046  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_forced_default_nexthop4_set" "', argument " "2"" of type '" "bool""'");
11047  }
11048  arg2 = static_cast< bool >(val2);
11049  if (arg1) (arg1)->forced_default_nexthop4 = arg2;
11050  resultobj = SWIG_Py_Void();
11051  return resultobj;
11052 fail:
11053  return NULL;
11054 }
11055 
11056 
11057 SWIGINTERN PyObject *_wrap_BgpConfig_forced_default_nexthop4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11058  PyObject *resultobj = 0;
11059  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11060  void *argp1 = 0 ;
11061  int res1 = 0 ;
11062  PyObject * obj0 = 0 ;
11063  bool result;
11064 
11065  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_forced_default_nexthop4_get",&obj0)) SWIG_fail;
11066  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11067  if (!SWIG_IsOK(res1)) {
11068  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_forced_default_nexthop4_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11069  }
11070  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11071  result = (bool) ((arg1)->forced_default_nexthop4);
11072  resultobj = SWIG_From_bool(static_cast< bool >(result));
11073  return resultobj;
11074 fail:
11075  return NULL;
11076 }
11077 
11078 
11079 SWIGINTERN PyObject *_wrap_BgpConfig_no_nexthop_check6_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11080  PyObject *resultobj = 0;
11081  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11082  bool arg2 ;
11083  void *argp1 = 0 ;
11084  int res1 = 0 ;
11085  bool val2 ;
11086  int ecode2 = 0 ;
11087  PyObject * obj0 = 0 ;
11088  PyObject * obj1 = 0 ;
11089 
11090  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_no_nexthop_check6_set",&obj0,&obj1)) SWIG_fail;
11091  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11092  if (!SWIG_IsOK(res1)) {
11093  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_no_nexthop_check6_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11094  }
11095  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11096  ecode2 = SWIG_AsVal_bool(obj1, &val2);
11097  if (!SWIG_IsOK(ecode2)) {
11098  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_no_nexthop_check6_set" "', argument " "2"" of type '" "bool""'");
11099  }
11100  arg2 = static_cast< bool >(val2);
11101  if (arg1) (arg1)->no_nexthop_check6 = arg2;
11102  resultobj = SWIG_Py_Void();
11103  return resultobj;
11104 fail:
11105  return NULL;
11106 }
11107 
11108 
11109 SWIGINTERN PyObject *_wrap_BgpConfig_no_nexthop_check6_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11110  PyObject *resultobj = 0;
11111  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11112  void *argp1 = 0 ;
11113  int res1 = 0 ;
11114  PyObject * obj0 = 0 ;
11115  bool result;
11116 
11117  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_no_nexthop_check6_get",&obj0)) SWIG_fail;
11118  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11119  if (!SWIG_IsOK(res1)) {
11120  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_no_nexthop_check6_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11121  }
11122  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11123  result = (bool) ((arg1)->no_nexthop_check6);
11124  resultobj = SWIG_From_bool(static_cast< bool >(result));
11125  return resultobj;
11126 fail:
11127  return NULL;
11128 }
11129 
11130 
11131 SWIGINTERN PyObject *_wrap_BgpConfig_default_nexthop6_global_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11132  PyObject *resultobj = 0;
11133  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11134  uint8_t *arg2 ;
11135  void *argp1 = 0 ;
11136  int res1 = 0 ;
11137  void *argp2 = 0 ;
11138  int res2 = 0 ;
11139  PyObject * obj0 = 0 ;
11140  PyObject * obj1 = 0 ;
11141 
11142  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_default_nexthop6_global_set",&obj0,&obj1)) SWIG_fail;
11143  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11144  if (!SWIG_IsOK(res1)) {
11145  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_default_nexthop6_global_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11146  }
11147  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11148  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
11149  if (!SWIG_IsOK(res2)) {
11150  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpConfig_default_nexthop6_global_set" "', argument " "2"" of type '" "uint8_t [16]""'");
11151  }
11152  arg2 = reinterpret_cast< uint8_t * >(argp2);
11153  {
11154  if (arg2) {
11155  size_t ii = 0;
11156  for (; ii < (size_t)16; ++ii) *(uint8_t *)&arg1->default_nexthop6_global[ii] = *((uint8_t *)arg2 + ii);
11157  } else {
11158  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""default_nexthop6_global""' of type '""uint8_t [16]""'");
11159  }
11160  }
11161  resultobj = SWIG_Py_Void();
11162  return resultobj;
11163 fail:
11164  return NULL;
11165 }
11166 
11167 
11168 SWIGINTERN PyObject *_wrap_BgpConfig_default_nexthop6_global_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11169  PyObject *resultobj = 0;
11170  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11171  void *argp1 = 0 ;
11172  int res1 = 0 ;
11173  PyObject * obj0 = 0 ;
11174  uint8_t *result = 0 ;
11175 
11176  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_default_nexthop6_global_get",&obj0)) SWIG_fail;
11177  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11178  if (!SWIG_IsOK(res1)) {
11179  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_default_nexthop6_global_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11180  }
11181  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11182  result = (uint8_t *)(uint8_t *) ((arg1)->default_nexthop6_global);
11183  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
11184  return resultobj;
11185 fail:
11186  return NULL;
11187 }
11188 
11189 
11190 SWIGINTERN PyObject *_wrap_BgpConfig_default_nexthop6_linklocal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11191  PyObject *resultobj = 0;
11192  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11193  uint8_t *arg2 ;
11194  void *argp1 = 0 ;
11195  int res1 = 0 ;
11196  void *argp2 = 0 ;
11197  int res2 = 0 ;
11198  PyObject * obj0 = 0 ;
11199  PyObject * obj1 = 0 ;
11200 
11201  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_default_nexthop6_linklocal_set",&obj0,&obj1)) SWIG_fail;
11202  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11203  if (!SWIG_IsOK(res1)) {
11204  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_default_nexthop6_linklocal_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11205  }
11206  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11207  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
11208  if (!SWIG_IsOK(res2)) {
11209  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpConfig_default_nexthop6_linklocal_set" "', argument " "2"" of type '" "uint8_t [16]""'");
11210  }
11211  arg2 = reinterpret_cast< uint8_t * >(argp2);
11212  {
11213  if (arg2) {
11214  size_t ii = 0;
11215  for (; ii < (size_t)16; ++ii) *(uint8_t *)&arg1->default_nexthop6_linklocal[ii] = *((uint8_t *)arg2 + ii);
11216  } else {
11217  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""default_nexthop6_linklocal""' of type '""uint8_t [16]""'");
11218  }
11219  }
11220  resultobj = SWIG_Py_Void();
11221  return resultobj;
11222 fail:
11223  return NULL;
11224 }
11225 
11226 
11227 SWIGINTERN PyObject *_wrap_BgpConfig_default_nexthop6_linklocal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11228  PyObject *resultobj = 0;
11229  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11230  void *argp1 = 0 ;
11231  int res1 = 0 ;
11232  PyObject * obj0 = 0 ;
11233  uint8_t *result = 0 ;
11234 
11235  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_default_nexthop6_linklocal_get",&obj0)) SWIG_fail;
11236  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11237  if (!SWIG_IsOK(res1)) {
11238  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_default_nexthop6_linklocal_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11239  }
11240  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11241  result = (uint8_t *)(uint8_t *) ((arg1)->default_nexthop6_linklocal);
11242  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
11243  return resultobj;
11244 fail:
11245  return NULL;
11246 }
11247 
11248 
11249 SWIGINTERN PyObject *_wrap_BgpConfig_forced_default_nexthop6_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11250  PyObject *resultobj = 0;
11251  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11252  bool arg2 ;
11253  void *argp1 = 0 ;
11254  int res1 = 0 ;
11255  bool val2 ;
11256  int ecode2 = 0 ;
11257  PyObject * obj0 = 0 ;
11258  PyObject * obj1 = 0 ;
11259 
11260  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_forced_default_nexthop6_set",&obj0,&obj1)) SWIG_fail;
11261  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11262  if (!SWIG_IsOK(res1)) {
11263  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_forced_default_nexthop6_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11264  }
11265  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11266  ecode2 = SWIG_AsVal_bool(obj1, &val2);
11267  if (!SWIG_IsOK(ecode2)) {
11268  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_forced_default_nexthop6_set" "', argument " "2"" of type '" "bool""'");
11269  }
11270  arg2 = static_cast< bool >(val2);
11271  if (arg1) (arg1)->forced_default_nexthop6 = arg2;
11272  resultobj = SWIG_Py_Void();
11273  return resultobj;
11274 fail:
11275  return NULL;
11276 }
11277 
11278 
11279 SWIGINTERN PyObject *_wrap_BgpConfig_forced_default_nexthop6_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11280  PyObject *resultobj = 0;
11281  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11282  void *argp1 = 0 ;
11283  int res1 = 0 ;
11284  PyObject * obj0 = 0 ;
11285  bool result;
11286 
11287  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_forced_default_nexthop6_get",&obj0)) SWIG_fail;
11288  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11289  if (!SWIG_IsOK(res1)) {
11290  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_forced_default_nexthop6_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11291  }
11292  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11293  result = (bool) ((arg1)->forced_default_nexthop6);
11294  resultobj = SWIG_From_bool(static_cast< bool >(result));
11295  return resultobj;
11296 fail:
11297  return NULL;
11298 }
11299 
11300 
11301 SWIGINTERN PyObject *_wrap_BgpConfig_hold_timer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11302  PyObject *resultobj = 0;
11303  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11304  uint16_t arg2 ;
11305  void *argp1 = 0 ;
11306  int res1 = 0 ;
11307  unsigned short val2 ;
11308  int ecode2 = 0 ;
11309  PyObject * obj0 = 0 ;
11310  PyObject * obj1 = 0 ;
11311 
11312  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_hold_timer_set",&obj0,&obj1)) SWIG_fail;
11313  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11314  if (!SWIG_IsOK(res1)) {
11315  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_hold_timer_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11316  }
11317  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11318  ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
11319  if (!SWIG_IsOK(ecode2)) {
11320  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_hold_timer_set" "', argument " "2"" of type '" "uint16_t""'");
11321  }
11322  arg2 = static_cast< uint16_t >(val2);
11323  if (arg1) (arg1)->hold_timer = arg2;
11324  resultobj = SWIG_Py_Void();
11325  return resultobj;
11326 fail:
11327  return NULL;
11328 }
11329 
11330 
11331 SWIGINTERN PyObject *_wrap_BgpConfig_hold_timer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11332  PyObject *resultobj = 0;
11333  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11334  void *argp1 = 0 ;
11335  int res1 = 0 ;
11336  PyObject * obj0 = 0 ;
11337  uint16_t result;
11338 
11339  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_hold_timer_get",&obj0)) SWIG_fail;
11340  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11341  if (!SWIG_IsOK(res1)) {
11342  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_hold_timer_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11343  }
11344  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11345  result = (uint16_t) ((arg1)->hold_timer);
11346  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
11347  return resultobj;
11348 fail:
11349  return NULL;
11350 }
11351 
11352 
11353 SWIGINTERN PyObject *_wrap_BgpConfig_clock_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11354  PyObject *resultobj = 0;
11355  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11356  Clock *arg2 = (Clock *) 0 ;
11357  void *argp1 = 0 ;
11358  int res1 = 0 ;
11359  void *argp2 = 0 ;
11360  int res2 = 0 ;
11361  PyObject * obj0 = 0 ;
11362  PyObject * obj1 = 0 ;
11363 
11364  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_clock_set",&obj0,&obj1)) SWIG_fail;
11365  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11366  if (!SWIG_IsOK(res1)) {
11367  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_clock_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11368  }
11369  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11370  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Clock, SWIG_POINTER_DISOWN | 0 );
11371  if (!SWIG_IsOK(res2)) {
11372  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpConfig_clock_set" "', argument " "2"" of type '" "Clock *""'");
11373  }
11374  arg2 = reinterpret_cast< Clock * >(argp2);
11375  if (arg1) (arg1)->clock = arg2;
11376  resultobj = SWIG_Py_Void();
11377  return resultobj;
11378 fail:
11379  return NULL;
11380 }
11381 
11382 
11383 SWIGINTERN PyObject *_wrap_BgpConfig_clock_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11384  PyObject *resultobj = 0;
11385  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11386  void *argp1 = 0 ;
11387  int res1 = 0 ;
11388  PyObject * obj0 = 0 ;
11389  Clock *result = 0 ;
11390 
11391  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_clock_get",&obj0)) SWIG_fail;
11392  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11393  if (!SWIG_IsOK(res1)) {
11394  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_clock_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11395  }
11396  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11397  result = (Clock *) ((arg1)->clock);
11398  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Clock, 0 | 0 );
11399  return resultobj;
11400 fail:
11401  return NULL;
11402 }
11403 
11404 
11405 SWIGINTERN PyObject *_wrap_BgpConfig_allow_local_as_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11406  PyObject *resultobj = 0;
11407  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11408  int8_t arg2 ;
11409  void *argp1 = 0 ;
11410  int res1 = 0 ;
11411  signed char val2 ;
11412  int ecode2 = 0 ;
11413  PyObject * obj0 = 0 ;
11414  PyObject * obj1 = 0 ;
11415 
11416  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_allow_local_as_set",&obj0,&obj1)) SWIG_fail;
11417  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11418  if (!SWIG_IsOK(res1)) {
11419  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_allow_local_as_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11420  }
11421  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11422  ecode2 = SWIG_AsVal_signed_SS_char(obj1, &val2);
11423  if (!SWIG_IsOK(ecode2)) {
11424  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_allow_local_as_set" "', argument " "2"" of type '" "int8_t""'");
11425  }
11426  arg2 = static_cast< int8_t >(val2);
11427  if (arg1) (arg1)->allow_local_as = arg2;
11428  resultobj = SWIG_Py_Void();
11429  return resultobj;
11430 fail:
11431  return NULL;
11432 }
11433 
11434 
11435 SWIGINTERN PyObject *_wrap_BgpConfig_allow_local_as_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11436  PyObject *resultobj = 0;
11437  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11438  void *argp1 = 0 ;
11439  int res1 = 0 ;
11440  PyObject * obj0 = 0 ;
11441  int8_t result;
11442 
11443  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_allow_local_as_get",&obj0)) SWIG_fail;
11444  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11445  if (!SWIG_IsOK(res1)) {
11446  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_allow_local_as_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11447  }
11448  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11449  result = (int8_t) ((arg1)->allow_local_as);
11450  resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
11451  return resultobj;
11452 fail:
11453  return NULL;
11454 }
11455 
11456 
11457 SWIGINTERN PyObject *_wrap_BgpConfig_weight_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11458  PyObject *resultobj = 0;
11459  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11460  int32_t arg2 ;
11461  void *argp1 = 0 ;
11462  int res1 = 0 ;
11463  int val2 ;
11464  int ecode2 = 0 ;
11465  PyObject * obj0 = 0 ;
11466  PyObject * obj1 = 0 ;
11467 
11468  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_weight_set",&obj0,&obj1)) SWIG_fail;
11469  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11470  if (!SWIG_IsOK(res1)) {
11471  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_weight_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11472  }
11473  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11474  ecode2 = SWIG_AsVal_int(obj1, &val2);
11475  if (!SWIG_IsOK(ecode2)) {
11476  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_weight_set" "', argument " "2"" of type '" "int32_t""'");
11477  }
11478  arg2 = static_cast< int32_t >(val2);
11479  if (arg1) (arg1)->weight = arg2;
11480  resultobj = SWIG_Py_Void();
11481  return resultobj;
11482 fail:
11483  return NULL;
11484 }
11485 
11486 
11487 SWIGINTERN PyObject *_wrap_BgpConfig_weight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11488  PyObject *resultobj = 0;
11489  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11490  void *argp1 = 0 ;
11491  int res1 = 0 ;
11492  PyObject * obj0 = 0 ;
11493  int32_t result;
11494 
11495  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_weight_get",&obj0)) SWIG_fail;
11496  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11497  if (!SWIG_IsOK(res1)) {
11498  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_weight_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11499  }
11500  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11501  result = (int32_t) ((arg1)->weight);
11502  resultobj = SWIG_From_int(static_cast< int >(result));
11503  return resultobj;
11504 fail:
11505  return NULL;
11506 }
11507 
11508 
11509 SWIGINTERN PyObject *_wrap_BgpConfig_no_autotick_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11510  PyObject *resultobj = 0;
11511  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11512  bool arg2 ;
11513  void *argp1 = 0 ;
11514  int res1 = 0 ;
11515  bool val2 ;
11516  int ecode2 = 0 ;
11517  PyObject * obj0 = 0 ;
11518  PyObject * obj1 = 0 ;
11519 
11520  if (!PyArg_ParseTuple(args,(char *)"OO:BgpConfig_no_autotick_set",&obj0,&obj1)) SWIG_fail;
11521  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11522  if (!SWIG_IsOK(res1)) {
11523  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_no_autotick_set" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11524  }
11525  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11526  ecode2 = SWIG_AsVal_bool(obj1, &val2);
11527  if (!SWIG_IsOK(ecode2)) {
11528  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpConfig_no_autotick_set" "', argument " "2"" of type '" "bool""'");
11529  }
11530  arg2 = static_cast< bool >(val2);
11531  if (arg1) (arg1)->no_autotick = arg2;
11532  resultobj = SWIG_Py_Void();
11533  return resultobj;
11534 fail:
11535  return NULL;
11536 }
11537 
11538 
11539 SWIGINTERN PyObject *_wrap_BgpConfig_no_autotick_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11540  PyObject *resultobj = 0;
11541  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11542  void *argp1 = 0 ;
11543  int res1 = 0 ;
11544  PyObject * obj0 = 0 ;
11545  bool result;
11546 
11547  if (!PyArg_ParseTuple(args,(char *)"O:BgpConfig_no_autotick_get",&obj0)) SWIG_fail;
11548  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, 0 | 0 );
11549  if (!SWIG_IsOK(res1)) {
11550  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpConfig_no_autotick_get" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11551  }
11552  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11553  result = (bool) ((arg1)->no_autotick);
11554  resultobj = SWIG_From_bool(static_cast< bool >(result));
11555  return resultobj;
11556 fail:
11557  return NULL;
11558 }
11559 
11560 
11561 SWIGINTERN PyObject *_wrap_delete_BgpConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11562  PyObject *resultobj = 0;
11563  libbgp::BgpConfig *arg1 = (libbgp::BgpConfig *) 0 ;
11564  void *argp1 = 0 ;
11565  int res1 = 0 ;
11566  PyObject * obj0 = 0 ;
11567 
11568  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpConfig",&obj0)) SWIG_fail;
11569  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpConfig, SWIG_POINTER_DISOWN | 0 );
11570  if (!SWIG_IsOK(res1)) {
11571  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpConfig" "', argument " "1"" of type '" "libbgp::BgpConfig *""'");
11572  }
11573  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11574  delete arg1;
11575  resultobj = SWIG_Py_Void();
11576  return resultobj;
11577 fail:
11578  return NULL;
11579 }
11580 
11581 
11582 SWIGINTERN PyObject *BgpConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11583  PyObject *obj;
11584  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
11585  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpConfig, SWIG_NewClientData(obj));
11586  return SWIG_Py_Void();
11587 }
11588 
11589 SWIGINTERN int Swig_var_bgp_error_code_str_set(PyObject *_val) {
11590  {
11591  char const * *inp = 0;
11592  int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_p_char, 0 );
11593  if (!SWIG_IsOK(res)) {
11594  SWIG_exception_fail(SWIG_ArgError(res), "in variable '""libbgp::bgp_error_code_str""' of type '""char const *[7]""'");
11595  } else if (inp) {
11596  size_t ii = 0;
11597  for (; ii < (size_t)7; ++ii) *(char const * *)&libbgp::bgp_error_code_str[ii] = *((char const * *)inp + ii);
11598  } else {
11599  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""libbgp::bgp_error_code_str""' of type '""char const *[7]""'");
11600  }
11601  }
11602  return 0;
11603 fail:
11604  return 1;
11605 }
11606 
11607 
11608 SWIGINTERN PyObject *Swig_var_bgp_error_code_str_get(void) {
11609  PyObject *pyobj = 0;
11610 
11611  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(libbgp::bgp_error_code_str), SWIGTYPE_p_p_char, 0 );
11612  return pyobj;
11613 }
11614 
11615 
11616 SWIGINTERN int Swig_var_bgp_header_error_subcode_str_set(PyObject *_val) {
11617  {
11618  char const * *inp = 0;
11619  int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_p_char, 0 );
11620  if (!SWIG_IsOK(res)) {
11621  SWIG_exception_fail(SWIG_ArgError(res), "in variable '""libbgp::bgp_header_error_subcode_str""' of type '""char const *[4]""'");
11622  } else if (inp) {
11623  size_t ii = 0;
11624  for (; ii < (size_t)4; ++ii) *(char const * *)&libbgp::bgp_header_error_subcode_str[ii] = *((char const * *)inp + ii);
11625  } else {
11626  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""libbgp::bgp_header_error_subcode_str""' of type '""char const *[4]""'");
11627  }
11628  }
11629  return 0;
11630 fail:
11631  return 1;
11632 }
11633 
11634 
11635 SWIGINTERN PyObject *Swig_var_bgp_header_error_subcode_str_get(void) {
11636  PyObject *pyobj = 0;
11637 
11638  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(libbgp::bgp_header_error_subcode_str), SWIGTYPE_p_p_char, 0 );
11639  return pyobj;
11640 }
11641 
11642 
11643 SWIGINTERN int Swig_var_bgp_open_error_subcode_str_set(PyObject *_val) {
11644  {
11645  char const * *inp = 0;
11646  int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_p_char, 0 );
11647  if (!SWIG_IsOK(res)) {
11648  SWIG_exception_fail(SWIG_ArgError(res), "in variable '""libbgp::bgp_open_error_subcode_str""' of type '""char const *[8]""'");
11649  } else if (inp) {
11650  size_t ii = 0;
11651  for (; ii < (size_t)8; ++ii) *(char const * *)&libbgp::bgp_open_error_subcode_str[ii] = *((char const * *)inp + ii);
11652  } else {
11653  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""libbgp::bgp_open_error_subcode_str""' of type '""char const *[8]""'");
11654  }
11655  }
11656  return 0;
11657 fail:
11658  return 1;
11659 }
11660 
11661 
11662 SWIGINTERN PyObject *Swig_var_bgp_open_error_subcode_str_get(void) {
11663  PyObject *pyobj = 0;
11664 
11665  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(libbgp::bgp_open_error_subcode_str), SWIGTYPE_p_p_char, 0 );
11666  return pyobj;
11667 }
11668 
11669 
11670 SWIGINTERN int Swig_var_bgp_update_error_str_set(PyObject *_val) {
11671  {
11672  char const * *inp = 0;
11673  int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_p_char, 0 );
11674  if (!SWIG_IsOK(res)) {
11675  SWIG_exception_fail(SWIG_ArgError(res), "in variable '""libbgp::bgp_update_error_str""' of type '""char const *[12]""'");
11676  } else if (inp) {
11677  size_t ii = 0;
11678  for (; ii < (size_t)12; ++ii) *(char const * *)&libbgp::bgp_update_error_str[ii] = *((char const * *)inp + ii);
11679  } else {
11680  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""libbgp::bgp_update_error_str""' of type '""char const *[12]""'");
11681  }
11682  }
11683  return 0;
11684 fail:
11685  return 1;
11686 }
11687 
11688 
11689 SWIGINTERN PyObject *Swig_var_bgp_update_error_str_get(void) {
11690  PyObject *pyobj = 0;
11691 
11692  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(libbgp::bgp_update_error_str), SWIGTYPE_p_p_char, 0 );
11693  return pyobj;
11694 }
11695 
11696 
11697 SWIGINTERN int Swig_var_bgp_fsm_error_str_set(PyObject *_val) {
11698  {
11699  char const * *inp = 0;
11700  int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_p_char, 0 );
11701  if (!SWIG_IsOK(res)) {
11702  SWIG_exception_fail(SWIG_ArgError(res), "in variable '""libbgp::bgp_fsm_error_str""' of type '""char const *[4]""'");
11703  } else if (inp) {
11704  size_t ii = 0;
11705  for (; ii < (size_t)4; ++ii) *(char const * *)&libbgp::bgp_fsm_error_str[ii] = *((char const * *)inp + ii);
11706  } else {
11707  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""libbgp::bgp_fsm_error_str""' of type '""char const *[4]""'");
11708  }
11709  }
11710  return 0;
11711 fail:
11712  return 1;
11713 }
11714 
11715 
11716 SWIGINTERN PyObject *Swig_var_bgp_fsm_error_str_get(void) {
11717  PyObject *pyobj = 0;
11718 
11719  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(libbgp::bgp_fsm_error_str), SWIGTYPE_p_p_char, 0 );
11720  return pyobj;
11721 }
11722 
11723 
11724 SWIGINTERN int Swig_var_bgp_cease_error_str_set(PyObject *_val) {
11725  {
11726  char const * *inp = 0;
11727  int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_p_char, 0 );
11728  if (!SWIG_IsOK(res)) {
11729  SWIG_exception_fail(SWIG_ArgError(res), "in variable '""libbgp::bgp_cease_error_str""' of type '""char const *[9]""'");
11730  } else if (inp) {
11731  size_t ii = 0;
11732  for (; ii < (size_t)9; ++ii) *(char const * *)&libbgp::bgp_cease_error_str[ii] = *((char const * *)inp + ii);
11733  } else {
11734  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""libbgp::bgp_cease_error_str""' of type '""char const *[9]""'");
11735  }
11736  }
11737  return 0;
11738 fail:
11739  return 1;
11740 }
11741 
11742 
11743 SWIGINTERN PyObject *Swig_var_bgp_cease_error_str_get(void) {
11744  PyObject *pyobj = 0;
11745 
11746  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(libbgp::bgp_cease_error_str), SWIGTYPE_p_p_char, 0 );
11747  return pyobj;
11748 }
11749 
11750 
11751 SWIGINTERN PyObject *_wrap_new_BgpFsm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11752  PyObject *resultobj = 0;
11753  libbgp::BgpConfig *arg1 = 0 ;
11754  void *argp1 = 0 ;
11755  int res1 = 0 ;
11756  PyObject * obj0 = 0 ;
11757  libbgp::BgpFsm *result = 0 ;
11758 
11759  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpFsm",&obj0)) SWIG_fail;
11760  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_libbgp__BgpConfig, 0 | 0);
11761  if (!SWIG_IsOK(res1)) {
11762  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpFsm" "', argument " "1"" of type '" "libbgp::BgpConfig const &""'");
11763  }
11764  if (!argp1) {
11765  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BgpFsm" "', argument " "1"" of type '" "libbgp::BgpConfig const &""'");
11766  }
11767  arg1 = reinterpret_cast< libbgp::BgpConfig * >(argp1);
11768  result = (libbgp::BgpFsm *)new libbgp::BgpFsm((libbgp::BgpConfig const &)*arg1);
11769  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpFsm, SWIG_POINTER_NEW | 0 );
11770  return resultobj;
11771 fail:
11772  return NULL;
11773 }
11774 
11775 
11776 SWIGINTERN PyObject *_wrap_delete_BgpFsm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11777  PyObject *resultobj = 0;
11778  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
11779  void *argp1 = 0 ;
11780  int res1 = 0 ;
11781  PyObject * obj0 = 0 ;
11782 
11783  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpFsm",&obj0)) SWIG_fail;
11784  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, SWIG_POINTER_DISOWN | 0 );
11785  if (!SWIG_IsOK(res1)) {
11786  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpFsm" "', argument " "1"" of type '" "libbgp::BgpFsm *""'");
11787  }
11788  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
11789  delete arg1;
11790  resultobj = SWIG_Py_Void();
11791  return resultobj;
11792 fail:
11793  return NULL;
11794 }
11795 
11796 
11797 SWIGINTERN PyObject *_wrap_BgpFsm_getAsn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11798  PyObject *resultobj = 0;
11799  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
11800  void *argp1 = 0 ;
11801  int res1 = 0 ;
11802  PyObject * obj0 = 0 ;
11803  uint32_t result;
11804 
11805  if (!PyArg_ParseTuple(args,(char *)"O:BgpFsm_getAsn",&obj0)) SWIG_fail;
11806  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, 0 | 0 );
11807  if (!SWIG_IsOK(res1)) {
11808  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFsm_getAsn" "', argument " "1"" of type '" "libbgp::BgpFsm const *""'");
11809  }
11810  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
11811  result = (uint32_t)((libbgp::BgpFsm const *)arg1)->getAsn();
11812  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
11813  return resultobj;
11814 fail:
11815  return NULL;
11816 }
11817 
11818 
11819 SWIGINTERN PyObject *_wrap_BgpFsm_getBgpId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11820  PyObject *resultobj = 0;
11821  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
11822  void *argp1 = 0 ;
11823  int res1 = 0 ;
11824  PyObject * obj0 = 0 ;
11825  uint32_t result;
11826 
11827  if (!PyArg_ParseTuple(args,(char *)"O:BgpFsm_getBgpId",&obj0)) SWIG_fail;
11828  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, 0 | 0 );
11829  if (!SWIG_IsOK(res1)) {
11830  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFsm_getBgpId" "', argument " "1"" of type '" "libbgp::BgpFsm const *""'");
11831  }
11832  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
11833  result = (uint32_t)((libbgp::BgpFsm const *)arg1)->getBgpId();
11834  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
11835  return resultobj;
11836 fail:
11837  return NULL;
11838 }
11839 
11840 
11841 SWIGINTERN PyObject *_wrap_BgpFsm_getPeerAsn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11842  PyObject *resultobj = 0;
11843  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
11844  void *argp1 = 0 ;
11845  int res1 = 0 ;
11846  PyObject * obj0 = 0 ;
11847  uint32_t result;
11848 
11849  if (!PyArg_ParseTuple(args,(char *)"O:BgpFsm_getPeerAsn",&obj0)) SWIG_fail;
11850  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, 0 | 0 );
11851  if (!SWIG_IsOK(res1)) {
11852  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFsm_getPeerAsn" "', argument " "1"" of type '" "libbgp::BgpFsm const *""'");
11853  }
11854  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
11855  result = (uint32_t)((libbgp::BgpFsm const *)arg1)->getPeerAsn();
11856  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
11857  return resultobj;
11858 fail:
11859  return NULL;
11860 }
11861 
11862 
11863 SWIGINTERN PyObject *_wrap_BgpFsm_getPeerBgpId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11864  PyObject *resultobj = 0;
11865  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
11866  void *argp1 = 0 ;
11867  int res1 = 0 ;
11868  PyObject * obj0 = 0 ;
11869  uint32_t result;
11870 
11871  if (!PyArg_ParseTuple(args,(char *)"O:BgpFsm_getPeerBgpId",&obj0)) SWIG_fail;
11872  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, 0 | 0 );
11873  if (!SWIG_IsOK(res1)) {
11874  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFsm_getPeerBgpId" "', argument " "1"" of type '" "libbgp::BgpFsm const *""'");
11875  }
11876  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
11877  result = (uint32_t)((libbgp::BgpFsm const *)arg1)->getPeerBgpId();
11878  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
11879  return resultobj;
11880 fail:
11881  return NULL;
11882 }
11883 
11884 
11885 SWIGINTERN PyObject *_wrap_BgpFsm_getHoldTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11886  PyObject *resultobj = 0;
11887  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
11888  void *argp1 = 0 ;
11889  int res1 = 0 ;
11890  PyObject * obj0 = 0 ;
11891  uint16_t result;
11892 
11893  if (!PyArg_ParseTuple(args,(char *)"O:BgpFsm_getHoldTimer",&obj0)) SWIG_fail;
11894  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, 0 | 0 );
11895  if (!SWIG_IsOK(res1)) {
11896  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFsm_getHoldTimer" "', argument " "1"" of type '" "libbgp::BgpFsm const *""'");
11897  }
11898  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
11899  result = (uint16_t)((libbgp::BgpFsm const *)arg1)->getHoldTimer();
11900  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
11901  return resultobj;
11902 fail:
11903  return NULL;
11904 }
11905 
11906 
11907 SWIGINTERN PyObject *_wrap_BgpFsm_getRib4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11908  PyObject *resultobj = 0;
11909  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
11910  void *argp1 = 0 ;
11911  int res1 = 0 ;
11912  PyObject * obj0 = 0 ;
11913  BgpRib4 *result = 0 ;
11914 
11915  if (!PyArg_ParseTuple(args,(char *)"O:BgpFsm_getRib4",&obj0)) SWIG_fail;
11916  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, 0 | 0 );
11917  if (!SWIG_IsOK(res1)) {
11918  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFsm_getRib4" "', argument " "1"" of type '" "libbgp::BgpFsm const *""'");
11919  }
11920  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
11921  result = (BgpRib4 *) &((libbgp::BgpFsm const *)arg1)->getRib4();
11922  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BgpRib4, 0 | 0 );
11923  return resultobj;
11924 fail:
11925  return NULL;
11926 }
11927 
11928 
11929 SWIGINTERN PyObject *_wrap_BgpFsm_getRib6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11930  PyObject *resultobj = 0;
11931  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
11932  void *argp1 = 0 ;
11933  int res1 = 0 ;
11934  PyObject * obj0 = 0 ;
11935  BgpRib6 *result = 0 ;
11936 
11937  if (!PyArg_ParseTuple(args,(char *)"O:BgpFsm_getRib6",&obj0)) SWIG_fail;
11938  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, 0 | 0 );
11939  if (!SWIG_IsOK(res1)) {
11940  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFsm_getRib6" "', argument " "1"" of type '" "libbgp::BgpFsm const *""'");
11941  }
11942  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
11943  result = (BgpRib6 *) &((libbgp::BgpFsm const *)arg1)->getRib6();
11944  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_BgpRib6, 0 | 0 );
11945  return resultobj;
11946 fail:
11947  return NULL;
11948 }
11949 
11950 
11951 SWIGINTERN PyObject *_wrap_BgpFsm_getState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11952  PyObject *resultobj = 0;
11953  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
11954  void *argp1 = 0 ;
11955  int res1 = 0 ;
11956  PyObject * obj0 = 0 ;
11957  libbgp::BgpState result;
11958 
11959  if (!PyArg_ParseTuple(args,(char *)"O:BgpFsm_getState",&obj0)) SWIG_fail;
11960  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, 0 | 0 );
11961  if (!SWIG_IsOK(res1)) {
11962  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFsm_getState" "', argument " "1"" of type '" "libbgp::BgpFsm const *""'");
11963  }
11964  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
11965  result = (libbgp::BgpState)((libbgp::BgpFsm const *)arg1)->getState();
11966  resultobj = SWIG_From_int(static_cast< int >(result));
11967  return resultobj;
11968 fail:
11969  return NULL;
11970 }
11971 
11972 
11973 SWIGINTERN PyObject *_wrap_BgpFsm_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11974  PyObject *resultobj = 0;
11975  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
11976  void *argp1 = 0 ;
11977  int res1 = 0 ;
11978  PyObject * obj0 = 0 ;
11979  int result;
11980 
11981  if (!PyArg_ParseTuple(args,(char *)"O:BgpFsm_start",&obj0)) SWIG_fail;
11982  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, 0 | 0 );
11983  if (!SWIG_IsOK(res1)) {
11984  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFsm_start" "', argument " "1"" of type '" "libbgp::BgpFsm *""'");
11985  }
11986  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
11987  result = (int)(arg1)->start();
11988  resultobj = SWIG_From_int(static_cast< int >(result));
11989  return resultobj;
11990 fail:
11991  return NULL;
11992 }
11993 
11994 
11995 SWIGINTERN PyObject *_wrap_BgpFsm_stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11996  PyObject *resultobj = 0;
11997  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
11998  void *argp1 = 0 ;
11999  int res1 = 0 ;
12000  PyObject * obj0 = 0 ;
12001  int result;
12002 
12003  if (!PyArg_ParseTuple(args,(char *)"O:BgpFsm_stop",&obj0)) SWIG_fail;
12004  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, 0 | 0 );
12005  if (!SWIG_IsOK(res1)) {
12006  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFsm_stop" "', argument " "1"" of type '" "libbgp::BgpFsm *""'");
12007  }
12008  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
12009  result = (int)(arg1)->stop();
12010  resultobj = SWIG_From_int(static_cast< int >(result));
12011  return resultobj;
12012 fail:
12013  return NULL;
12014 }
12015 
12016 
12017 SWIGINTERN PyObject *_wrap_BgpFsm_run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12018  PyObject *resultobj = 0;
12019  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
12020  uint8_t *arg2 = (uint8_t *) 0 ;
12021  size_t arg3 ;
12022  void *argp1 = 0 ;
12023  int res1 = 0 ;
12024  void *argp2 = 0 ;
12025  int res2 = 0 ;
12026  size_t val3 ;
12027  int ecode3 = 0 ;
12028  PyObject * obj0 = 0 ;
12029  PyObject * obj1 = 0 ;
12030  PyObject * obj2 = 0 ;
12031  int result;
12032 
12033  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpFsm_run",&obj0,&obj1,&obj2)) SWIG_fail;
12034  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, 0 | 0 );
12035  if (!SWIG_IsOK(res1)) {
12036  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFsm_run" "', argument " "1"" of type '" "libbgp::BgpFsm *""'");
12037  }
12038  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
12039  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
12040  if (!SWIG_IsOK(res2)) {
12041  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpFsm_run" "', argument " "2"" of type '" "uint8_t const *""'");
12042  }
12043  arg2 = reinterpret_cast< uint8_t * >(argp2);
12044  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
12045  if (!SWIG_IsOK(ecode3)) {
12046  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpFsm_run" "', argument " "3"" of type '" "size_t""'");
12047  }
12048  arg3 = static_cast< size_t >(val3);
12049  result = (int)(arg1)->run((uint8_t const *)arg2,arg3);
12050  resultobj = SWIG_From_int(static_cast< int >(result));
12051  return resultobj;
12052 fail:
12053  return NULL;
12054 }
12055 
12056 
12057 SWIGINTERN PyObject *_wrap_BgpFsm_tick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12058  PyObject *resultobj = 0;
12059  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
12060  void *argp1 = 0 ;
12061  int res1 = 0 ;
12062  PyObject * obj0 = 0 ;
12063  int result;
12064 
12065  if (!PyArg_ParseTuple(args,(char *)"O:BgpFsm_tick",&obj0)) SWIG_fail;
12066  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, 0 | 0 );
12067  if (!SWIG_IsOK(res1)) {
12068  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFsm_tick" "', argument " "1"" of type '" "libbgp::BgpFsm *""'");
12069  }
12070  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
12071  result = (int)(arg1)->tick();
12072  resultobj = SWIG_From_int(static_cast< int >(result));
12073  return resultobj;
12074 fail:
12075  return NULL;
12076 }
12077 
12078 
12079 SWIGINTERN PyObject *_wrap_BgpFsm_resetSoft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12080  PyObject *resultobj = 0;
12081  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
12082  void *argp1 = 0 ;
12083  int res1 = 0 ;
12084  PyObject * obj0 = 0 ;
12085  int result;
12086 
12087  if (!PyArg_ParseTuple(args,(char *)"O:BgpFsm_resetSoft",&obj0)) SWIG_fail;
12088  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, 0 | 0 );
12089  if (!SWIG_IsOK(res1)) {
12090  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFsm_resetSoft" "', argument " "1"" of type '" "libbgp::BgpFsm *""'");
12091  }
12092  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
12093  result = (int)(arg1)->resetSoft();
12094  resultobj = SWIG_From_int(static_cast< int >(result));
12095  return resultobj;
12096 fail:
12097  return NULL;
12098 }
12099 
12100 
12101 SWIGINTERN PyObject *_wrap_BgpFsm_resetHard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12102  PyObject *resultobj = 0;
12103  libbgp::BgpFsm *arg1 = (libbgp::BgpFsm *) 0 ;
12104  void *argp1 = 0 ;
12105  int res1 = 0 ;
12106  PyObject * obj0 = 0 ;
12107 
12108  if (!PyArg_ParseTuple(args,(char *)"O:BgpFsm_resetHard",&obj0)) SWIG_fail;
12109  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpFsm, 0 | 0 );
12110  if (!SWIG_IsOK(res1)) {
12111  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpFsm_resetHard" "', argument " "1"" of type '" "libbgp::BgpFsm *""'");
12112  }
12113  arg1 = reinterpret_cast< libbgp::BgpFsm * >(argp1);
12114  (arg1)->resetHard();
12115  resultobj = SWIG_Py_Void();
12116  return resultobj;
12117 fail:
12118  return NULL;
12119 }
12120 
12121 
12122 SWIGINTERN PyObject *BgpFsm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12123  PyObject *obj;
12124  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
12125  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpFsm, SWIG_NewClientData(obj));
12126  return SWIG_Py_Void();
12127 }
12128 
12129 SWIGINTERN PyObject *_wrap_new_BgpLogHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12130  PyObject *resultobj = 0;
12131  libbgp::BgpLogHandler *result = 0 ;
12132 
12133  if (!PyArg_ParseTuple(args,(char *)":new_BgpLogHandler")) SWIG_fail;
12134  result = (libbgp::BgpLogHandler *)new libbgp::BgpLogHandler();
12135  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpLogHandler, SWIG_POINTER_NEW | 0 );
12136  return resultobj;
12137 fail:
12138  return NULL;
12139 }
12140 
12141 
12142 SWIGINTERN PyObject *_wrap_BgpLogHandler_log__SWIG_0__varargs__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *varargs) {
12143  PyObject *resultobj = 0;
12145  libbgp::LogLevel arg2 ;
12146  char *arg3 = (char *) 0 ;
12147  void *arg4 = 0 ;
12148  void *argp1 = 0 ;
12149  int res1 = 0 ;
12150  int val2 ;
12151  int ecode2 = 0 ;
12152  int res3 ;
12153  char *buf3 = 0 ;
12154  int alloc3 = 0 ;
12155  PyObject * obj0 = 0 ;
12156  PyObject * obj1 = 0 ;
12157  PyObject * obj2 = 0 ;
12158 
12159  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpLogHandler_log",&obj0,&obj1,&obj2)) SWIG_fail;
12160  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
12161  if (!SWIG_IsOK(res1)) {
12162  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpLogHandler_log" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
12163  }
12164  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
12165  ecode2 = SWIG_AsVal_int(obj1, &val2);
12166  if (!SWIG_IsOK(ecode2)) {
12167  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpLogHandler_log" "', argument " "2"" of type '" "libbgp::LogLevel""'");
12168  }
12169  arg2 = static_cast< libbgp::LogLevel >(val2);
12170  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
12171  if (!SWIG_IsOK(res3)) {
12172  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpLogHandler_log" "', argument " "3"" of type '" "char const *""'");
12173  }
12174  arg3 = reinterpret_cast< char * >(buf3);
12175  (arg1)->log(arg2,(char const *)arg3,arg4);
12176  resultobj = SWIG_Py_Void();
12177  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
12178  return resultobj;
12179 fail:
12180  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
12181  return NULL;
12182 }
12183 
12184 
12185 SWIGINTERN PyObject *_wrap_BgpLogHandler_log__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12186  PyObject *resultobj;
12187  PyObject *varargs;
12188  PyObject *newargs;
12189 
12190  newargs = PyTuple_GetSlice(args,0,3);
12191  varargs = PyTuple_GetSlice(args,3,PyTuple_Size(args));
12192  resultobj = _wrap_BgpLogHandler_log__SWIG_0__varargs__(NULL,newargs,varargs);
12193  Py_XDECREF(newargs);
12194  Py_XDECREF(varargs);
12195  return resultobj;
12196 }
12197 
12198 
12199 SWIGINTERN PyObject *_wrap_BgpLogHandler_log__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12200  PyObject *resultobj = 0;
12202  libbgp::LogLevel arg2 ;
12203  libbgp::Serializable *arg3 = 0 ;
12204  void *argp1 = 0 ;
12205  int res1 = 0 ;
12206  int val2 ;
12207  int ecode2 = 0 ;
12208  void *argp3 = 0 ;
12209  int res3 = 0 ;
12210  PyObject * obj0 = 0 ;
12211  PyObject * obj1 = 0 ;
12212  PyObject * obj2 = 0 ;
12213 
12214  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpLogHandler_log",&obj0,&obj1,&obj2)) SWIG_fail;
12215  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
12216  if (!SWIG_IsOK(res1)) {
12217  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpLogHandler_log" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
12218  }
12219  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
12220  ecode2 = SWIG_AsVal_int(obj1, &val2);
12221  if (!SWIG_IsOK(ecode2)) {
12222  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpLogHandler_log" "', argument " "2"" of type '" "libbgp::LogLevel""'");
12223  }
12224  arg2 = static_cast< libbgp::LogLevel >(val2);
12225  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Serializable, 0 | 0);
12226  if (!SWIG_IsOK(res3)) {
12227  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpLogHandler_log" "', argument " "3"" of type '" "libbgp::Serializable const &""'");
12228  }
12229  if (!argp3) {
12230  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpLogHandler_log" "', argument " "3"" of type '" "libbgp::Serializable const &""'");
12231  }
12232  arg3 = reinterpret_cast< libbgp::Serializable * >(argp3);
12233  (arg1)->log(arg2,(libbgp::Serializable const &)*arg3);
12234  resultobj = SWIG_Py_Void();
12235  return resultobj;
12236 fail:
12237  return NULL;
12238 }
12239 
12240 
12241 SWIGINTERN PyObject *_wrap_BgpLogHandler_log(PyObject *self, PyObject *args) {
12242  Py_ssize_t argc;
12243  PyObject *argv[4] = {
12244  0
12245  };
12246  Py_ssize_t ii;
12247 
12248  if (!PyTuple_Check(args)) SWIG_fail;
12249  argc = args ? PyObject_Length(args) : 0;
12250  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
12251  argv[ii] = PyTuple_GET_ITEM(args,ii);
12252  }
12253  if (argc == 3) {
12254  int _v;
12255  void *vptr = 0;
12256  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
12257  _v = SWIG_CheckState(res);
12258  if (_v) {
12259  {
12260  int res = SWIG_AsVal_int(argv[1], NULL);
12261  _v = SWIG_CheckState(res);
12262  }
12263  if (_v) {
12264  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_libbgp__Serializable, 0);
12265  _v = SWIG_CheckState(res);
12266  if (_v) {
12267  return _wrap_BgpLogHandler_log__SWIG_1(self, args);
12268  }
12269  }
12270  }
12271  }
12272  if (argc == 3) {
12273  int _v;
12274  void *vptr = 0;
12275  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
12276  _v = SWIG_CheckState(res);
12277  if (_v) {
12278  {
12279  int res = SWIG_AsVal_int(argv[1], NULL);
12280  _v = SWIG_CheckState(res);
12281  }
12282  if (_v) {
12283  int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
12284  _v = SWIG_CheckState(res);
12285  if (_v) {
12286  if (argc <= 3) {
12287  return _wrap_BgpLogHandler_log__SWIG_0(self, args);
12288  }
12289  return _wrap_BgpLogHandler_log__SWIG_0(self, args);
12290  }
12291  }
12292  }
12293  }
12294 
12295 fail:
12296  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BgpLogHandler_log'.\n"
12297  " Possible C/C++ prototypes are:\n"
12298  " libbgp::BgpLogHandler::log(libbgp::LogLevel,char const *,...)\n"
12299  " libbgp::BgpLogHandler::log(libbgp::LogLevel,libbgp::Serializable const &)\n");
12300  return 0;
12301 }
12302 
12303 
12304 SWIGINTERN PyObject *_wrap_BgpLogHandler_setLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12305  PyObject *resultobj = 0;
12307  libbgp::LogLevel arg2 ;
12308  void *argp1 = 0 ;
12309  int res1 = 0 ;
12310  int val2 ;
12311  int ecode2 = 0 ;
12312  PyObject * obj0 = 0 ;
12313  PyObject * obj1 = 0 ;
12314 
12315  if (!PyArg_ParseTuple(args,(char *)"OO:BgpLogHandler_setLogLevel",&obj0,&obj1)) SWIG_fail;
12316  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
12317  if (!SWIG_IsOK(res1)) {
12318  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpLogHandler_setLogLevel" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
12319  }
12320  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
12321  ecode2 = SWIG_AsVal_int(obj1, &val2);
12322  if (!SWIG_IsOK(ecode2)) {
12323  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpLogHandler_setLogLevel" "', argument " "2"" of type '" "libbgp::LogLevel""'");
12324  }
12325  arg2 = static_cast< libbgp::LogLevel >(val2);
12326  (arg1)->setLogLevel(arg2);
12327  resultobj = SWIG_Py_Void();
12328  return resultobj;
12329 fail:
12330  return NULL;
12331 }
12332 
12333 
12334 SWIGINTERN PyObject *_wrap_BgpLogHandler_getLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12335  PyObject *resultobj = 0;
12337  void *argp1 = 0 ;
12338  int res1 = 0 ;
12339  PyObject * obj0 = 0 ;
12340  libbgp::LogLevel result;
12341 
12342  if (!PyArg_ParseTuple(args,(char *)"O:BgpLogHandler_getLogLevel",&obj0)) SWIG_fail;
12343  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
12344  if (!SWIG_IsOK(res1)) {
12345  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpLogHandler_getLogLevel" "', argument " "1"" of type '" "libbgp::BgpLogHandler const *""'");
12346  }
12347  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
12348  result = (libbgp::LogLevel)((libbgp::BgpLogHandler const *)arg1)->getLogLevel();
12349  resultobj = SWIG_From_int(static_cast< int >(result));
12350  return resultobj;
12351 fail:
12352  return NULL;
12353 }
12354 
12355 
12356 SWIGINTERN PyObject *_wrap_delete_BgpLogHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12357  PyObject *resultobj = 0;
12359  void *argp1 = 0 ;
12360  int res1 = 0 ;
12361  PyObject * obj0 = 0 ;
12362 
12363  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpLogHandler",&obj0)) SWIG_fail;
12364  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, SWIG_POINTER_DISOWN | 0 );
12365  if (!SWIG_IsOK(res1)) {
12366  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpLogHandler" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
12367  }
12368  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
12369  delete arg1;
12370  resultobj = SWIG_Py_Void();
12371  return resultobj;
12372 fail:
12373  return NULL;
12374 }
12375 
12376 
12377 SWIGINTERN PyObject *BgpLogHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12378  PyObject *obj;
12379  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
12380  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpLogHandler, SWIG_NewClientData(obj));
12381  return SWIG_Py_Void();
12382 }
12383 
12384 SWIGINTERN PyObject *_wrap_BgpMessage_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12385  PyObject *resultobj = 0;
12386  libbgp::BgpMessage *arg1 = (libbgp::BgpMessage *) 0 ;
12387  uint8_t *arg2 = (uint8_t *) 0 ;
12388  size_t arg3 ;
12389  void *argp1 = 0 ;
12390  int res1 = 0 ;
12391  void *argp2 = 0 ;
12392  int res2 = 0 ;
12393  size_t val3 ;
12394  int ecode3 = 0 ;
12395  PyObject * obj0 = 0 ;
12396  PyObject * obj1 = 0 ;
12397  PyObject * obj2 = 0 ;
12398  ssize_t result;
12399 
12400  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpMessage_parse",&obj0,&obj1,&obj2)) SWIG_fail;
12401  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpMessage, 0 | 0 );
12402  if (!SWIG_IsOK(res1)) {
12403  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpMessage_parse" "', argument " "1"" of type '" "libbgp::BgpMessage *""'");
12404  }
12405  arg1 = reinterpret_cast< libbgp::BgpMessage * >(argp1);
12406  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
12407  if (!SWIG_IsOK(res2)) {
12408  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpMessage_parse" "', argument " "2"" of type '" "uint8_t const *""'");
12409  }
12410  arg2 = reinterpret_cast< uint8_t * >(argp2);
12411  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
12412  if (!SWIG_IsOK(ecode3)) {
12413  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpMessage_parse" "', argument " "3"" of type '" "size_t""'");
12414  }
12415  arg3 = static_cast< size_t >(val3);
12416  result = (arg1)->parse((uint8_t const *)arg2,arg3);
12417  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
12418  return resultobj;
12419 fail:
12420  return NULL;
12421 }
12422 
12423 
12424 SWIGINTERN PyObject *_wrap_BgpMessage_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12425  PyObject *resultobj = 0;
12426  libbgp::BgpMessage *arg1 = (libbgp::BgpMessage *) 0 ;
12427  uint8_t *arg2 = (uint8_t *) 0 ;
12428  size_t arg3 ;
12429  void *argp1 = 0 ;
12430  int res1 = 0 ;
12431  void *argp2 = 0 ;
12432  int res2 = 0 ;
12433  size_t val3 ;
12434  int ecode3 = 0 ;
12435  PyObject * obj0 = 0 ;
12436  PyObject * obj1 = 0 ;
12437  PyObject * obj2 = 0 ;
12438  ssize_t result;
12439 
12440  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpMessage_write",&obj0,&obj1,&obj2)) SWIG_fail;
12441  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpMessage, 0 | 0 );
12442  if (!SWIG_IsOK(res1)) {
12443  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpMessage_write" "', argument " "1"" of type '" "libbgp::BgpMessage const *""'");
12444  }
12445  arg1 = reinterpret_cast< libbgp::BgpMessage * >(argp1);
12446  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
12447  if (!SWIG_IsOK(res2)) {
12448  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpMessage_write" "', argument " "2"" of type '" "uint8_t *""'");
12449  }
12450  arg2 = reinterpret_cast< uint8_t * >(argp2);
12451  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
12452  if (!SWIG_IsOK(ecode3)) {
12453  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpMessage_write" "', argument " "3"" of type '" "size_t""'");
12454  }
12455  arg3 = static_cast< size_t >(val3);
12456  result = ((libbgp::BgpMessage const *)arg1)->write(arg2,arg3);
12457  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
12458  return resultobj;
12459 fail:
12460  return NULL;
12461 }
12462 
12463 
12464 SWIGINTERN PyObject *_wrap_BgpMessage_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12465  PyObject *resultobj = 0;
12466  libbgp::BgpMessage *arg1 = (libbgp::BgpMessage *) 0 ;
12467  uint8_t arg2 ;
12468  void *argp1 = 0 ;
12469  int res1 = 0 ;
12470  unsigned char val2 ;
12471  int ecode2 = 0 ;
12472  PyObject * obj0 = 0 ;
12473  PyObject * obj1 = 0 ;
12474 
12475  if (!PyArg_ParseTuple(args,(char *)"OO:BgpMessage_type_set",&obj0,&obj1)) SWIG_fail;
12476  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpMessage, 0 | 0 );
12477  if (!SWIG_IsOK(res1)) {
12478  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpMessage_type_set" "', argument " "1"" of type '" "libbgp::BgpMessage *""'");
12479  }
12480  arg1 = reinterpret_cast< libbgp::BgpMessage * >(argp1);
12481  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12482  if (!SWIG_IsOK(ecode2)) {
12483  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpMessage_type_set" "', argument " "2"" of type '" "uint8_t""'");
12484  }
12485  arg2 = static_cast< uint8_t >(val2);
12486  if (arg1) (arg1)->type = arg2;
12487  resultobj = SWIG_Py_Void();
12488  return resultobj;
12489 fail:
12490  return NULL;
12491 }
12492 
12493 
12494 SWIGINTERN PyObject *_wrap_BgpMessage_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12495  PyObject *resultobj = 0;
12496  libbgp::BgpMessage *arg1 = (libbgp::BgpMessage *) 0 ;
12497  void *argp1 = 0 ;
12498  int res1 = 0 ;
12499  PyObject * obj0 = 0 ;
12500  uint8_t result;
12501 
12502  if (!PyArg_ParseTuple(args,(char *)"O:BgpMessage_type_get",&obj0)) SWIG_fail;
12503  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpMessage, 0 | 0 );
12504  if (!SWIG_IsOK(res1)) {
12505  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpMessage_type_get" "', argument " "1"" of type '" "libbgp::BgpMessage *""'");
12506  }
12507  arg1 = reinterpret_cast< libbgp::BgpMessage * >(argp1);
12508  result = (uint8_t) ((arg1)->type);
12509  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12510  return resultobj;
12511 fail:
12512  return NULL;
12513 }
12514 
12515 
12516 SWIGINTERN PyObject *_wrap_delete_BgpMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12517  PyObject *resultobj = 0;
12518  libbgp::BgpMessage *arg1 = (libbgp::BgpMessage *) 0 ;
12519  void *argp1 = 0 ;
12520  int res1 = 0 ;
12521  PyObject * obj0 = 0 ;
12522 
12523  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpMessage",&obj0)) SWIG_fail;
12524  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpMessage, SWIG_POINTER_DISOWN | 0 );
12525  if (!SWIG_IsOK(res1)) {
12526  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpMessage" "', argument " "1"" of type '" "libbgp::BgpMessage *""'");
12527  }
12528  arg1 = reinterpret_cast< libbgp::BgpMessage * >(argp1);
12529  delete arg1;
12530  resultobj = SWIG_Py_Void();
12531  return resultobj;
12532 fail:
12533  return NULL;
12534 }
12535 
12536 
12537 SWIGINTERN PyObject *BgpMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12538  PyObject *obj;
12539  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
12540  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpMessage, SWIG_NewClientData(obj));
12541  return SWIG_Py_Void();
12542 }
12543 
12544 SWIGINTERN PyObject *_wrap_new_BgpBadMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12545  PyObject *resultobj = 0;
12547  uint8_t arg2 ;
12548  void *argp1 = 0 ;
12549  int res1 = 0 ;
12550  unsigned char val2 ;
12551  int ecode2 = 0 ;
12552  PyObject * obj0 = 0 ;
12553  PyObject * obj1 = 0 ;
12554  libbgp::BgpBadMessage *result = 0 ;
12555 
12556  if (!PyArg_ParseTuple(args,(char *)"OO:new_BgpBadMessage",&obj0,&obj1)) SWIG_fail;
12557  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
12558  if (!SWIG_IsOK(res1)) {
12559  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpBadMessage" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
12560  }
12561  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
12562  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12563  if (!SWIG_IsOK(ecode2)) {
12564  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpBadMessage" "', argument " "2"" of type '" "uint8_t""'");
12565  }
12566  arg2 = static_cast< uint8_t >(val2);
12567  result = (libbgp::BgpBadMessage *)new libbgp::BgpBadMessage(arg1,arg2);
12568  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpBadMessage, SWIG_POINTER_NEW | 0 );
12569  return resultobj;
12570 fail:
12571  return NULL;
12572 }
12573 
12574 
12575 SWIGINTERN PyObject *_wrap_BgpBadMessage_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12576  PyObject *resultobj = 0;
12578  size_t arg2 ;
12579  uint8_t **arg3 = (uint8_t **) 0 ;
12580  size_t *arg4 = (size_t *) 0 ;
12581  void *argp1 = 0 ;
12582  int res1 = 0 ;
12583  size_t val2 ;
12584  int ecode2 = 0 ;
12585  void *argp3 = 0 ;
12586  int res3 = 0 ;
12587  void *argp4 = 0 ;
12588  int res4 = 0 ;
12589  PyObject * obj0 = 0 ;
12590  PyObject * obj1 = 0 ;
12591  PyObject * obj2 = 0 ;
12592  PyObject * obj3 = 0 ;
12593  ssize_t result;
12594 
12595  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpBadMessage_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12596  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpBadMessage, 0 | 0 );
12597  if (!SWIG_IsOK(res1)) {
12598  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpBadMessage_doPrint" "', argument " "1"" of type '" "libbgp::BgpBadMessage const *""'");
12599  }
12600  arg1 = reinterpret_cast< libbgp::BgpBadMessage * >(argp1);
12601  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
12602  if (!SWIG_IsOK(ecode2)) {
12603  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpBadMessage_doPrint" "', argument " "2"" of type '" "size_t""'");
12604  }
12605  arg2 = static_cast< size_t >(val2);
12606  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
12607  if (!SWIG_IsOK(res3)) {
12608  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpBadMessage_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
12609  }
12610  arg3 = reinterpret_cast< uint8_t ** >(argp3);
12611  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
12612  if (!SWIG_IsOK(res4)) {
12613  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpBadMessage_doPrint" "', argument " "4"" of type '" "size_t *""'");
12614  }
12615  arg4 = reinterpret_cast< size_t * >(argp4);
12616  result = ((libbgp::BgpBadMessage const *)arg1)->doPrint(arg2,arg3,arg4);
12617  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
12618  return resultobj;
12619 fail:
12620  return NULL;
12621 }
12622 
12623 
12624 SWIGINTERN PyObject *_wrap_BgpBadMessage_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12625  PyObject *resultobj = 0;
12627  uint8_t *arg2 = (uint8_t *) 0 ;
12628  size_t arg3 ;
12629  void *argp1 = 0 ;
12630  int res1 = 0 ;
12631  void *argp2 = 0 ;
12632  int res2 = 0 ;
12633  size_t val3 ;
12634  int ecode3 = 0 ;
12635  PyObject * obj0 = 0 ;
12636  PyObject * obj1 = 0 ;
12637  PyObject * obj2 = 0 ;
12638  ssize_t result;
12639 
12640  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpBadMessage_parse",&obj0,&obj1,&obj2)) SWIG_fail;
12641  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpBadMessage, 0 | 0 );
12642  if (!SWIG_IsOK(res1)) {
12643  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpBadMessage_parse" "', argument " "1"" of type '" "libbgp::BgpBadMessage *""'");
12644  }
12645  arg1 = reinterpret_cast< libbgp::BgpBadMessage * >(argp1);
12646  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
12647  if (!SWIG_IsOK(res2)) {
12648  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpBadMessage_parse" "', argument " "2"" of type '" "uint8_t const *""'");
12649  }
12650  arg2 = reinterpret_cast< uint8_t * >(argp2);
12651  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
12652  if (!SWIG_IsOK(ecode3)) {
12653  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpBadMessage_parse" "', argument " "3"" of type '" "size_t""'");
12654  }
12655  arg3 = static_cast< size_t >(val3);
12656  result = (arg1)->parse((uint8_t const *)arg2,arg3);
12657  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
12658  return resultobj;
12659 fail:
12660  return NULL;
12661 }
12662 
12663 
12664 SWIGINTERN PyObject *_wrap_BgpBadMessage_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12665  PyObject *resultobj = 0;
12667  uint8_t *arg2 = (uint8_t *) 0 ;
12668  size_t arg3 ;
12669  void *argp1 = 0 ;
12670  int res1 = 0 ;
12671  void *argp2 = 0 ;
12672  int res2 = 0 ;
12673  size_t val3 ;
12674  int ecode3 = 0 ;
12675  PyObject * obj0 = 0 ;
12676  PyObject * obj1 = 0 ;
12677  PyObject * obj2 = 0 ;
12678  ssize_t result;
12679 
12680  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpBadMessage_write",&obj0,&obj1,&obj2)) SWIG_fail;
12681  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpBadMessage, 0 | 0 );
12682  if (!SWIG_IsOK(res1)) {
12683  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpBadMessage_write" "', argument " "1"" of type '" "libbgp::BgpBadMessage const *""'");
12684  }
12685  arg1 = reinterpret_cast< libbgp::BgpBadMessage * >(argp1);
12686  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
12687  if (!SWIG_IsOK(res2)) {
12688  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpBadMessage_write" "', argument " "2"" of type '" "uint8_t *""'");
12689  }
12690  arg2 = reinterpret_cast< uint8_t * >(argp2);
12691  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
12692  if (!SWIG_IsOK(ecode3)) {
12693  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpBadMessage_write" "', argument " "3"" of type '" "size_t""'");
12694  }
12695  arg3 = static_cast< size_t >(val3);
12696  result = ((libbgp::BgpBadMessage const *)arg1)->write(arg2,arg3);
12697  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
12698  return resultobj;
12699 fail:
12700  return NULL;
12701 }
12702 
12703 
12704 SWIGINTERN PyObject *_wrap_delete_BgpBadMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12705  PyObject *resultobj = 0;
12707  void *argp1 = 0 ;
12708  int res1 = 0 ;
12709  PyObject * obj0 = 0 ;
12710 
12711  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpBadMessage",&obj0)) SWIG_fail;
12712  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpBadMessage, SWIG_POINTER_DISOWN | 0 );
12713  if (!SWIG_IsOK(res1)) {
12714  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpBadMessage" "', argument " "1"" of type '" "libbgp::BgpBadMessage *""'");
12715  }
12716  arg1 = reinterpret_cast< libbgp::BgpBadMessage * >(argp1);
12717  delete arg1;
12718  resultobj = SWIG_Py_Void();
12719  return resultobj;
12720 fail:
12721  return NULL;
12722 }
12723 
12724 
12725 SWIGINTERN PyObject *BgpBadMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12726  PyObject *obj;
12727  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
12728  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpBadMessage, SWIG_NewClientData(obj));
12729  return SWIG_Py_Void();
12730 }
12731 
12732 SWIGINTERN PyObject *_wrap_new_BgpKeepaliveMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12733  PyObject *resultobj = 0;
12735  void *argp1 = 0 ;
12736  int res1 = 0 ;
12737  PyObject * obj0 = 0 ;
12738  libbgp::BgpKeepaliveMessage *result = 0 ;
12739 
12740  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpKeepaliveMessage",&obj0)) SWIG_fail;
12741  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
12742  if (!SWIG_IsOK(res1)) {
12743  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpKeepaliveMessage" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
12744  }
12745  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
12747  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpKeepaliveMessage, SWIG_POINTER_NEW | 0 );
12748  return resultobj;
12749 fail:
12750  return NULL;
12751 }
12752 
12753 
12754 SWIGINTERN PyObject *_wrap_BgpKeepaliveMessage_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12755  PyObject *resultobj = 0;
12757  size_t arg2 ;
12758  uint8_t **arg3 = (uint8_t **) 0 ;
12759  size_t *arg4 = (size_t *) 0 ;
12760  void *argp1 = 0 ;
12761  int res1 = 0 ;
12762  size_t val2 ;
12763  int ecode2 = 0 ;
12764  void *argp3 = 0 ;
12765  int res3 = 0 ;
12766  void *argp4 = 0 ;
12767  int res4 = 0 ;
12768  PyObject * obj0 = 0 ;
12769  PyObject * obj1 = 0 ;
12770  PyObject * obj2 = 0 ;
12771  PyObject * obj3 = 0 ;
12772  ssize_t result;
12773 
12774  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpKeepaliveMessage_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12775  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpKeepaliveMessage, 0 | 0 );
12776  if (!SWIG_IsOK(res1)) {
12777  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpKeepaliveMessage_doPrint" "', argument " "1"" of type '" "libbgp::BgpKeepaliveMessage const *""'");
12778  }
12779  arg1 = reinterpret_cast< libbgp::BgpKeepaliveMessage * >(argp1);
12780  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
12781  if (!SWIG_IsOK(ecode2)) {
12782  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpKeepaliveMessage_doPrint" "', argument " "2"" of type '" "size_t""'");
12783  }
12784  arg2 = static_cast< size_t >(val2);
12785  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
12786  if (!SWIG_IsOK(res3)) {
12787  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpKeepaliveMessage_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
12788  }
12789  arg3 = reinterpret_cast< uint8_t ** >(argp3);
12790  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
12791  if (!SWIG_IsOK(res4)) {
12792  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpKeepaliveMessage_doPrint" "', argument " "4"" of type '" "size_t *""'");
12793  }
12794  arg4 = reinterpret_cast< size_t * >(argp4);
12795  result = ((libbgp::BgpKeepaliveMessage const *)arg1)->doPrint(arg2,arg3,arg4);
12796  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
12797  return resultobj;
12798 fail:
12799  return NULL;
12800 }
12801 
12802 
12803 SWIGINTERN PyObject *_wrap_BgpKeepaliveMessage_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12804  PyObject *resultobj = 0;
12806  uint8_t *arg2 = (uint8_t *) 0 ;
12807  size_t arg3 ;
12808  void *argp1 = 0 ;
12809  int res1 = 0 ;
12810  void *argp2 = 0 ;
12811  int res2 = 0 ;
12812  size_t val3 ;
12813  int ecode3 = 0 ;
12814  PyObject * obj0 = 0 ;
12815  PyObject * obj1 = 0 ;
12816  PyObject * obj2 = 0 ;
12817  ssize_t result;
12818 
12819  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpKeepaliveMessage_parse",&obj0,&obj1,&obj2)) SWIG_fail;
12820  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpKeepaliveMessage, 0 | 0 );
12821  if (!SWIG_IsOK(res1)) {
12822  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpKeepaliveMessage_parse" "', argument " "1"" of type '" "libbgp::BgpKeepaliveMessage *""'");
12823  }
12824  arg1 = reinterpret_cast< libbgp::BgpKeepaliveMessage * >(argp1);
12825  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
12826  if (!SWIG_IsOK(res2)) {
12827  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpKeepaliveMessage_parse" "', argument " "2"" of type '" "uint8_t const *""'");
12828  }
12829  arg2 = reinterpret_cast< uint8_t * >(argp2);
12830  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
12831  if (!SWIG_IsOK(ecode3)) {
12832  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpKeepaliveMessage_parse" "', argument " "3"" of type '" "size_t""'");
12833  }
12834  arg3 = static_cast< size_t >(val3);
12835  result = (arg1)->parse((uint8_t const *)arg2,arg3);
12836  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
12837  return resultobj;
12838 fail:
12839  return NULL;
12840 }
12841 
12842 
12843 SWIGINTERN PyObject *_wrap_BgpKeepaliveMessage_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12844  PyObject *resultobj = 0;
12846  uint8_t *arg2 = (uint8_t *) 0 ;
12847  size_t arg3 ;
12848  void *argp1 = 0 ;
12849  int res1 = 0 ;
12850  void *argp2 = 0 ;
12851  int res2 = 0 ;
12852  size_t val3 ;
12853  int ecode3 = 0 ;
12854  PyObject * obj0 = 0 ;
12855  PyObject * obj1 = 0 ;
12856  PyObject * obj2 = 0 ;
12857  ssize_t result;
12858 
12859  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpKeepaliveMessage_write",&obj0,&obj1,&obj2)) SWIG_fail;
12860  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpKeepaliveMessage, 0 | 0 );
12861  if (!SWIG_IsOK(res1)) {
12862  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpKeepaliveMessage_write" "', argument " "1"" of type '" "libbgp::BgpKeepaliveMessage const *""'");
12863  }
12864  arg1 = reinterpret_cast< libbgp::BgpKeepaliveMessage * >(argp1);
12865  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
12866  if (!SWIG_IsOK(res2)) {
12867  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpKeepaliveMessage_write" "', argument " "2"" of type '" "uint8_t *""'");
12868  }
12869  arg2 = reinterpret_cast< uint8_t * >(argp2);
12870  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
12871  if (!SWIG_IsOK(ecode3)) {
12872  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpKeepaliveMessage_write" "', argument " "3"" of type '" "size_t""'");
12873  }
12874  arg3 = static_cast< size_t >(val3);
12875  result = ((libbgp::BgpKeepaliveMessage const *)arg1)->write(arg2,arg3);
12876  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
12877  return resultobj;
12878 fail:
12879  return NULL;
12880 }
12881 
12882 
12883 SWIGINTERN PyObject *_wrap_delete_BgpKeepaliveMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12884  PyObject *resultobj = 0;
12886  void *argp1 = 0 ;
12887  int res1 = 0 ;
12888  PyObject * obj0 = 0 ;
12889 
12890  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpKeepaliveMessage",&obj0)) SWIG_fail;
12891  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpKeepaliveMessage, SWIG_POINTER_DISOWN | 0 );
12892  if (!SWIG_IsOK(res1)) {
12893  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpKeepaliveMessage" "', argument " "1"" of type '" "libbgp::BgpKeepaliveMessage *""'");
12894  }
12895  arg1 = reinterpret_cast< libbgp::BgpKeepaliveMessage * >(argp1);
12896  delete arg1;
12897  resultobj = SWIG_Py_Void();
12898  return resultobj;
12899 fail:
12900  return NULL;
12901 }
12902 
12903 
12904 SWIGINTERN PyObject *BgpKeepaliveMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12905  PyObject *obj;
12906  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
12907  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpKeepaliveMessage, SWIG_NewClientData(obj));
12908  return SWIG_Py_Void();
12909 }
12910 
12911 SWIGINTERN PyObject *_wrap_new_BgpNotificationMessage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12912  PyObject *resultobj = 0;
12914  void *argp1 = 0 ;
12915  int res1 = 0 ;
12916  PyObject * obj0 = 0 ;
12917  libbgp::BgpNotificationMessage *result = 0 ;
12918 
12919  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpNotificationMessage",&obj0)) SWIG_fail;
12920  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
12921  if (!SWIG_IsOK(res1)) {
12922  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpNotificationMessage" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
12923  }
12924  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
12926  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpNotificationMessage, SWIG_POINTER_NEW | 0 );
12927  return resultobj;
12928 fail:
12929  return NULL;
12930 }
12931 
12932 
12933 SWIGINTERN PyObject *_wrap_new_BgpNotificationMessage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12934  PyObject *resultobj = 0;
12936  uint8_t arg2 ;
12937  uint8_t arg3 ;
12938  uint8_t *arg4 = (uint8_t *) 0 ;
12939  uint16_t arg5 ;
12940  void *argp1 = 0 ;
12941  int res1 = 0 ;
12942  unsigned char val2 ;
12943  int ecode2 = 0 ;
12944  unsigned char val3 ;
12945  int ecode3 = 0 ;
12946  void *argp4 = 0 ;
12947  int res4 = 0 ;
12948  unsigned short val5 ;
12949  int ecode5 = 0 ;
12950  PyObject * obj0 = 0 ;
12951  PyObject * obj1 = 0 ;
12952  PyObject * obj2 = 0 ;
12953  PyObject * obj3 = 0 ;
12954  PyObject * obj4 = 0 ;
12955  libbgp::BgpNotificationMessage *result = 0 ;
12956 
12957  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_BgpNotificationMessage",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12958  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
12959  if (!SWIG_IsOK(res1)) {
12960  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpNotificationMessage" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
12961  }
12962  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
12963  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12964  if (!SWIG_IsOK(ecode2)) {
12965  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpNotificationMessage" "', argument " "2"" of type '" "uint8_t""'");
12966  }
12967  arg2 = static_cast< uint8_t >(val2);
12968  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12969  if (!SWIG_IsOK(ecode3)) {
12970  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BgpNotificationMessage" "', argument " "3"" of type '" "uint8_t""'");
12971  }
12972  arg3 = static_cast< uint8_t >(val3);
12973  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
12974  if (!SWIG_IsOK(res4)) {
12975  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BgpNotificationMessage" "', argument " "4"" of type '" "uint8_t const *""'");
12976  }
12977  arg4 = reinterpret_cast< uint8_t * >(argp4);
12978  ecode5 = SWIG_AsVal_unsigned_SS_short(obj4, &val5);
12979  if (!SWIG_IsOK(ecode5)) {
12980  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_BgpNotificationMessage" "', argument " "5"" of type '" "uint16_t""'");
12981  }
12982  arg5 = static_cast< uint16_t >(val5);
12983  result = (libbgp::BgpNotificationMessage *)new libbgp::BgpNotificationMessage(arg1,arg2,arg3,(uint8_t const *)arg4,arg5);
12984  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpNotificationMessage, SWIG_POINTER_NEW | 0 );
12985  return resultobj;
12986 fail:
12987  return NULL;
12988 }
12989 
12990 
12991 SWIGINTERN PyObject *_wrap_new_BgpNotificationMessage(PyObject *self, PyObject *args) {
12992  Py_ssize_t argc;
12993  PyObject *argv[6] = {
12994  0
12995  };
12996  Py_ssize_t ii;
12997 
12998  if (!PyTuple_Check(args)) SWIG_fail;
12999  argc = args ? PyObject_Length(args) : 0;
13000  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
13001  argv[ii] = PyTuple_GET_ITEM(args,ii);
13002  }
13003  if (argc == 1) {
13004  int _v;
13005  void *vptr = 0;
13006  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
13007  _v = SWIG_CheckState(res);
13008  if (_v) {
13009  return _wrap_new_BgpNotificationMessage__SWIG_0(self, args);
13010  }
13011  }
13012  if (argc == 5) {
13013  int _v;
13014  void *vptr = 0;
13015  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
13016  _v = SWIG_CheckState(res);
13017  if (_v) {
13018  {
13019  int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
13020  _v = SWIG_CheckState(res);
13021  }
13022  if (_v) {
13023  {
13024  int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
13025  _v = SWIG_CheckState(res);
13026  }
13027  if (_v) {
13028  void *vptr = 0;
13029  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
13030  _v = SWIG_CheckState(res);
13031  if (_v) {
13032  {
13033  int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
13034  _v = SWIG_CheckState(res);
13035  }
13036  if (_v) {
13037  return _wrap_new_BgpNotificationMessage__SWIG_1(self, args);
13038  }
13039  }
13040  }
13041  }
13042  }
13043  }
13044 
13045 fail:
13046  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BgpNotificationMessage'.\n"
13047  " Possible C/C++ prototypes are:\n"
13048  " libbgp::BgpNotificationMessage::BgpNotificationMessage(libbgp::BgpLogHandler *)\n"
13049  " libbgp::BgpNotificationMessage::BgpNotificationMessage(libbgp::BgpLogHandler *,uint8_t,uint8_t,uint8_t const *,uint16_t)\n");
13050  return 0;
13051 }
13052 
13053 
13054 SWIGINTERN PyObject *_wrap_delete_BgpNotificationMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13055  PyObject *resultobj = 0;
13057  void *argp1 = 0 ;
13058  int res1 = 0 ;
13059  PyObject * obj0 = 0 ;
13060 
13061  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpNotificationMessage",&obj0)) SWIG_fail;
13062  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpNotificationMessage, SWIG_POINTER_DISOWN | 0 );
13063  if (!SWIG_IsOK(res1)) {
13064  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpNotificationMessage" "', argument " "1"" of type '" "libbgp::BgpNotificationMessage *""'");
13065  }
13066  arg1 = reinterpret_cast< libbgp::BgpNotificationMessage * >(argp1);
13067  delete arg1;
13068  resultobj = SWIG_Py_Void();
13069  return resultobj;
13070 fail:
13071  return NULL;
13072 }
13073 
13074 
13075 SWIGINTERN PyObject *_wrap_BgpNotificationMessage_errcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13076  PyObject *resultobj = 0;
13078  uint8_t arg2 ;
13079  void *argp1 = 0 ;
13080  int res1 = 0 ;
13081  unsigned char val2 ;
13082  int ecode2 = 0 ;
13083  PyObject * obj0 = 0 ;
13084  PyObject * obj1 = 0 ;
13085 
13086  if (!PyArg_ParseTuple(args,(char *)"OO:BgpNotificationMessage_errcode_set",&obj0,&obj1)) SWIG_fail;
13087  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpNotificationMessage, 0 | 0 );
13088  if (!SWIG_IsOK(res1)) {
13089  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpNotificationMessage_errcode_set" "', argument " "1"" of type '" "libbgp::BgpNotificationMessage *""'");
13090  }
13091  arg1 = reinterpret_cast< libbgp::BgpNotificationMessage * >(argp1);
13092  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
13093  if (!SWIG_IsOK(ecode2)) {
13094  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpNotificationMessage_errcode_set" "', argument " "2"" of type '" "uint8_t""'");
13095  }
13096  arg2 = static_cast< uint8_t >(val2);
13097  if (arg1) (arg1)->errcode = arg2;
13098  resultobj = SWIG_Py_Void();
13099  return resultobj;
13100 fail:
13101  return NULL;
13102 }
13103 
13104 
13105 SWIGINTERN PyObject *_wrap_BgpNotificationMessage_errcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13106  PyObject *resultobj = 0;
13108  void *argp1 = 0 ;
13109  int res1 = 0 ;
13110  PyObject * obj0 = 0 ;
13111  uint8_t result;
13112 
13113  if (!PyArg_ParseTuple(args,(char *)"O:BgpNotificationMessage_errcode_get",&obj0)) SWIG_fail;
13114  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpNotificationMessage, 0 | 0 );
13115  if (!SWIG_IsOK(res1)) {
13116  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpNotificationMessage_errcode_get" "', argument " "1"" of type '" "libbgp::BgpNotificationMessage *""'");
13117  }
13118  arg1 = reinterpret_cast< libbgp::BgpNotificationMessage * >(argp1);
13119  result = (uint8_t) ((arg1)->errcode);
13120  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13121  return resultobj;
13122 fail:
13123  return NULL;
13124 }
13125 
13126 
13127 SWIGINTERN PyObject *_wrap_BgpNotificationMessage_subcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13128  PyObject *resultobj = 0;
13130  uint8_t arg2 ;
13131  void *argp1 = 0 ;
13132  int res1 = 0 ;
13133  unsigned char val2 ;
13134  int ecode2 = 0 ;
13135  PyObject * obj0 = 0 ;
13136  PyObject * obj1 = 0 ;
13137 
13138  if (!PyArg_ParseTuple(args,(char *)"OO:BgpNotificationMessage_subcode_set",&obj0,&obj1)) SWIG_fail;
13139  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpNotificationMessage, 0 | 0 );
13140  if (!SWIG_IsOK(res1)) {
13141  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpNotificationMessage_subcode_set" "', argument " "1"" of type '" "libbgp::BgpNotificationMessage *""'");
13142  }
13143  arg1 = reinterpret_cast< libbgp::BgpNotificationMessage * >(argp1);
13144  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
13145  if (!SWIG_IsOK(ecode2)) {
13146  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpNotificationMessage_subcode_set" "', argument " "2"" of type '" "uint8_t""'");
13147  }
13148  arg2 = static_cast< uint8_t >(val2);
13149  if (arg1) (arg1)->subcode = arg2;
13150  resultobj = SWIG_Py_Void();
13151  return resultobj;
13152 fail:
13153  return NULL;
13154 }
13155 
13156 
13157 SWIGINTERN PyObject *_wrap_BgpNotificationMessage_subcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13158  PyObject *resultobj = 0;
13160  void *argp1 = 0 ;
13161  int res1 = 0 ;
13162  PyObject * obj0 = 0 ;
13163  uint8_t result;
13164 
13165  if (!PyArg_ParseTuple(args,(char *)"O:BgpNotificationMessage_subcode_get",&obj0)) SWIG_fail;
13166  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpNotificationMessage, 0 | 0 );
13167  if (!SWIG_IsOK(res1)) {
13168  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpNotificationMessage_subcode_get" "', argument " "1"" of type '" "libbgp::BgpNotificationMessage *""'");
13169  }
13170  arg1 = reinterpret_cast< libbgp::BgpNotificationMessage * >(argp1);
13171  result = (uint8_t) ((arg1)->subcode);
13172  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13173  return resultobj;
13174 fail:
13175  return NULL;
13176 }
13177 
13178 
13179 SWIGINTERN PyObject *_wrap_BgpNotificationMessage_data_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13180  PyObject *resultobj = 0;
13182  uint8_t *arg2 = (uint8_t *) 0 ;
13183  void *argp1 = 0 ;
13184  int res1 = 0 ;
13185  void *argp2 = 0 ;
13186  int res2 = 0 ;
13187  PyObject * obj0 = 0 ;
13188  PyObject * obj1 = 0 ;
13189 
13190  if (!PyArg_ParseTuple(args,(char *)"OO:BgpNotificationMessage_data_set",&obj0,&obj1)) SWIG_fail;
13191  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpNotificationMessage, 0 | 0 );
13192  if (!SWIG_IsOK(res1)) {
13193  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpNotificationMessage_data_set" "', argument " "1"" of type '" "libbgp::BgpNotificationMessage *""'");
13194  }
13195  arg1 = reinterpret_cast< libbgp::BgpNotificationMessage * >(argp1);
13196  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN | 0 );
13197  if (!SWIG_IsOK(res2)) {
13198  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpNotificationMessage_data_set" "', argument " "2"" of type '" "uint8_t *""'");
13199  }
13200  arg2 = reinterpret_cast< uint8_t * >(argp2);
13201  if (arg1) (arg1)->data = arg2;
13202  resultobj = SWIG_Py_Void();
13203  return resultobj;
13204 fail:
13205  return NULL;
13206 }
13207 
13208 
13209 SWIGINTERN PyObject *_wrap_BgpNotificationMessage_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13210  PyObject *resultobj = 0;
13212  void *argp1 = 0 ;
13213  int res1 = 0 ;
13214  PyObject * obj0 = 0 ;
13215  uint8_t *result = 0 ;
13216 
13217  if (!PyArg_ParseTuple(args,(char *)"O:BgpNotificationMessage_data_get",&obj0)) SWIG_fail;
13218  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpNotificationMessage, 0 | 0 );
13219  if (!SWIG_IsOK(res1)) {
13220  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpNotificationMessage_data_get" "', argument " "1"" of type '" "libbgp::BgpNotificationMessage *""'");
13221  }
13222  arg1 = reinterpret_cast< libbgp::BgpNotificationMessage * >(argp1);
13223  result = (uint8_t *) ((arg1)->data);
13224  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
13225  return resultobj;
13226 fail:
13227  return NULL;
13228 }
13229 
13230 
13231 SWIGINTERN PyObject *_wrap_BgpNotificationMessage_data_len_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13232  PyObject *resultobj = 0;
13234  uint16_t arg2 ;
13235  void *argp1 = 0 ;
13236  int res1 = 0 ;
13237  unsigned short val2 ;
13238  int ecode2 = 0 ;
13239  PyObject * obj0 = 0 ;
13240  PyObject * obj1 = 0 ;
13241 
13242  if (!PyArg_ParseTuple(args,(char *)"OO:BgpNotificationMessage_data_len_set",&obj0,&obj1)) SWIG_fail;
13243  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpNotificationMessage, 0 | 0 );
13244  if (!SWIG_IsOK(res1)) {
13245  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpNotificationMessage_data_len_set" "', argument " "1"" of type '" "libbgp::BgpNotificationMessage *""'");
13246  }
13247  arg1 = reinterpret_cast< libbgp::BgpNotificationMessage * >(argp1);
13248  ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
13249  if (!SWIG_IsOK(ecode2)) {
13250  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpNotificationMessage_data_len_set" "', argument " "2"" of type '" "uint16_t""'");
13251  }
13252  arg2 = static_cast< uint16_t >(val2);
13253  if (arg1) (arg1)->data_len = arg2;
13254  resultobj = SWIG_Py_Void();
13255  return resultobj;
13256 fail:
13257  return NULL;
13258 }
13259 
13260 
13261 SWIGINTERN PyObject *_wrap_BgpNotificationMessage_data_len_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13262  PyObject *resultobj = 0;
13264  void *argp1 = 0 ;
13265  int res1 = 0 ;
13266  PyObject * obj0 = 0 ;
13267  uint16_t result;
13268 
13269  if (!PyArg_ParseTuple(args,(char *)"O:BgpNotificationMessage_data_len_get",&obj0)) SWIG_fail;
13270  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpNotificationMessage, 0 | 0 );
13271  if (!SWIG_IsOK(res1)) {
13272  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpNotificationMessage_data_len_get" "', argument " "1"" of type '" "libbgp::BgpNotificationMessage *""'");
13273  }
13274  arg1 = reinterpret_cast< libbgp::BgpNotificationMessage * >(argp1);
13275  result = (uint16_t) ((arg1)->data_len);
13276  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
13277  return resultobj;
13278 fail:
13279  return NULL;
13280 }
13281 
13282 
13283 SWIGINTERN PyObject *_wrap_BgpNotificationMessage_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13284  PyObject *resultobj = 0;
13286  size_t arg2 ;
13287  uint8_t **arg3 = (uint8_t **) 0 ;
13288  size_t *arg4 = (size_t *) 0 ;
13289  void *argp1 = 0 ;
13290  int res1 = 0 ;
13291  size_t val2 ;
13292  int ecode2 = 0 ;
13293  void *argp3 = 0 ;
13294  int res3 = 0 ;
13295  void *argp4 = 0 ;
13296  int res4 = 0 ;
13297  PyObject * obj0 = 0 ;
13298  PyObject * obj1 = 0 ;
13299  PyObject * obj2 = 0 ;
13300  PyObject * obj3 = 0 ;
13301  ssize_t result;
13302 
13303  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpNotificationMessage_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13304  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpNotificationMessage, 0 | 0 );
13305  if (!SWIG_IsOK(res1)) {
13306  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpNotificationMessage_doPrint" "', argument " "1"" of type '" "libbgp::BgpNotificationMessage const *""'");
13307  }
13308  arg1 = reinterpret_cast< libbgp::BgpNotificationMessage * >(argp1);
13309  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
13310  if (!SWIG_IsOK(ecode2)) {
13311  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpNotificationMessage_doPrint" "', argument " "2"" of type '" "size_t""'");
13312  }
13313  arg2 = static_cast< size_t >(val2);
13314  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
13315  if (!SWIG_IsOK(res3)) {
13316  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpNotificationMessage_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
13317  }
13318  arg3 = reinterpret_cast< uint8_t ** >(argp3);
13319  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
13320  if (!SWIG_IsOK(res4)) {
13321  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpNotificationMessage_doPrint" "', argument " "4"" of type '" "size_t *""'");
13322  }
13323  arg4 = reinterpret_cast< size_t * >(argp4);
13324  result = ((libbgp::BgpNotificationMessage const *)arg1)->doPrint(arg2,arg3,arg4);
13325  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
13326  return resultobj;
13327 fail:
13328  return NULL;
13329 }
13330 
13331 
13332 SWIGINTERN PyObject *_wrap_BgpNotificationMessage_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13333  PyObject *resultobj = 0;
13335  uint8_t *arg2 = (uint8_t *) 0 ;
13336  size_t arg3 ;
13337  void *argp1 = 0 ;
13338  int res1 = 0 ;
13339  void *argp2 = 0 ;
13340  int res2 = 0 ;
13341  size_t val3 ;
13342  int ecode3 = 0 ;
13343  PyObject * obj0 = 0 ;
13344  PyObject * obj1 = 0 ;
13345  PyObject * obj2 = 0 ;
13346  ssize_t result;
13347 
13348  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpNotificationMessage_parse",&obj0,&obj1,&obj2)) SWIG_fail;
13349  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpNotificationMessage, 0 | 0 );
13350  if (!SWIG_IsOK(res1)) {
13351  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpNotificationMessage_parse" "', argument " "1"" of type '" "libbgp::BgpNotificationMessage *""'");
13352  }
13353  arg1 = reinterpret_cast< libbgp::BgpNotificationMessage * >(argp1);
13354  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
13355  if (!SWIG_IsOK(res2)) {
13356  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpNotificationMessage_parse" "', argument " "2"" of type '" "uint8_t const *""'");
13357  }
13358  arg2 = reinterpret_cast< uint8_t * >(argp2);
13359  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
13360  if (!SWIG_IsOK(ecode3)) {
13361  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpNotificationMessage_parse" "', argument " "3"" of type '" "size_t""'");
13362  }
13363  arg3 = static_cast< size_t >(val3);
13364  result = (arg1)->parse((uint8_t const *)arg2,arg3);
13365  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
13366  return resultobj;
13367 fail:
13368  return NULL;
13369 }
13370 
13371 
13372 SWIGINTERN PyObject *_wrap_BgpNotificationMessage_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13373  PyObject *resultobj = 0;
13375  uint8_t *arg2 = (uint8_t *) 0 ;
13376  size_t arg3 ;
13377  void *argp1 = 0 ;
13378  int res1 = 0 ;
13379  void *argp2 = 0 ;
13380  int res2 = 0 ;
13381  size_t val3 ;
13382  int ecode3 = 0 ;
13383  PyObject * obj0 = 0 ;
13384  PyObject * obj1 = 0 ;
13385  PyObject * obj2 = 0 ;
13386  ssize_t result;
13387 
13388  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpNotificationMessage_write",&obj0,&obj1,&obj2)) SWIG_fail;
13389  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpNotificationMessage, 0 | 0 );
13390  if (!SWIG_IsOK(res1)) {
13391  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpNotificationMessage_write" "', argument " "1"" of type '" "libbgp::BgpNotificationMessage const *""'");
13392  }
13393  arg1 = reinterpret_cast< libbgp::BgpNotificationMessage * >(argp1);
13394  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
13395  if (!SWIG_IsOK(res2)) {
13396  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpNotificationMessage_write" "', argument " "2"" of type '" "uint8_t *""'");
13397  }
13398  arg2 = reinterpret_cast< uint8_t * >(argp2);
13399  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
13400  if (!SWIG_IsOK(ecode3)) {
13401  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpNotificationMessage_write" "', argument " "3"" of type '" "size_t""'");
13402  }
13403  arg3 = static_cast< size_t >(val3);
13404  result = ((libbgp::BgpNotificationMessage const *)arg1)->write(arg2,arg3);
13405  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
13406  return resultobj;
13407 fail:
13408  return NULL;
13409 }
13410 
13411 
13412 SWIGINTERN PyObject *BgpNotificationMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13413  PyObject *obj;
13414  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
13415  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpNotificationMessage, SWIG_NewClientData(obj));
13416  return SWIG_Py_Void();
13417 }
13418 
13419 SWIGINTERN PyObject *_wrap_new_BgpOpenMessage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13420  PyObject *resultobj = 0;
13422  bool arg2 ;
13423  void *argp1 = 0 ;
13424  int res1 = 0 ;
13425  bool val2 ;
13426  int ecode2 = 0 ;
13427  PyObject * obj0 = 0 ;
13428  PyObject * obj1 = 0 ;
13429  libbgp::BgpOpenMessage *result = 0 ;
13430 
13431  if (!PyArg_ParseTuple(args,(char *)"OO:new_BgpOpenMessage",&obj0,&obj1)) SWIG_fail;
13432  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
13433  if (!SWIG_IsOK(res1)) {
13434  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpOpenMessage" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
13435  }
13436  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
13437  ecode2 = SWIG_AsVal_bool(obj1, &val2);
13438  if (!SWIG_IsOK(ecode2)) {
13439  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpOpenMessage" "', argument " "2"" of type '" "bool""'");
13440  }
13441  arg2 = static_cast< bool >(val2);
13442  result = (libbgp::BgpOpenMessage *)new libbgp::BgpOpenMessage(arg1,arg2);
13443  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpOpenMessage, SWIG_POINTER_NEW | 0 );
13444  return resultobj;
13445 fail:
13446  return NULL;
13447 }
13448 
13449 
13450 SWIGINTERN PyObject *_wrap_new_BgpOpenMessage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13451  PyObject *resultobj = 0;
13453  bool arg2 ;
13454  uint16_t arg3 ;
13455  uint16_t arg4 ;
13456  uint32_t arg5 ;
13457  void *argp1 = 0 ;
13458  int res1 = 0 ;
13459  bool val2 ;
13460  int ecode2 = 0 ;
13461  unsigned short val3 ;
13462  int ecode3 = 0 ;
13463  unsigned short val4 ;
13464  int ecode4 = 0 ;
13465  unsigned int val5 ;
13466  int ecode5 = 0 ;
13467  PyObject * obj0 = 0 ;
13468  PyObject * obj1 = 0 ;
13469  PyObject * obj2 = 0 ;
13470  PyObject * obj3 = 0 ;
13471  PyObject * obj4 = 0 ;
13472  libbgp::BgpOpenMessage *result = 0 ;
13473 
13474  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_BgpOpenMessage",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13475  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
13476  if (!SWIG_IsOK(res1)) {
13477  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpOpenMessage" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
13478  }
13479  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
13480  ecode2 = SWIG_AsVal_bool(obj1, &val2);
13481  if (!SWIG_IsOK(ecode2)) {
13482  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpOpenMessage" "', argument " "2"" of type '" "bool""'");
13483  }
13484  arg2 = static_cast< bool >(val2);
13485  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
13486  if (!SWIG_IsOK(ecode3)) {
13487  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BgpOpenMessage" "', argument " "3"" of type '" "uint16_t""'");
13488  }
13489  arg3 = static_cast< uint16_t >(val3);
13490  ecode4 = SWIG_AsVal_unsigned_SS_short(obj3, &val4);
13491  if (!SWIG_IsOK(ecode4)) {
13492  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BgpOpenMessage" "', argument " "4"" of type '" "uint16_t""'");
13493  }
13494  arg4 = static_cast< uint16_t >(val4);
13495  ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
13496  if (!SWIG_IsOK(ecode5)) {
13497  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_BgpOpenMessage" "', argument " "5"" of type '" "uint32_t""'");
13498  }
13499  arg5 = static_cast< uint32_t >(val5);
13500  result = (libbgp::BgpOpenMessage *)new libbgp::BgpOpenMessage(arg1,arg2,arg3,arg4,arg5);
13501  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpOpenMessage, SWIG_POINTER_NEW | 0 );
13502  return resultobj;
13503 fail:
13504  return NULL;
13505 }
13506 
13507 
13508 SWIGINTERN PyObject *_wrap_new_BgpOpenMessage__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13509  PyObject *resultobj = 0;
13511  bool arg2 ;
13512  uint16_t arg3 ;
13513  uint16_t arg4 ;
13514  char *arg5 = (char *) 0 ;
13515  void *argp1 = 0 ;
13516  int res1 = 0 ;
13517  bool val2 ;
13518  int ecode2 = 0 ;
13519  unsigned short val3 ;
13520  int ecode3 = 0 ;
13521  unsigned short val4 ;
13522  int ecode4 = 0 ;
13523  int res5 ;
13524  char *buf5 = 0 ;
13525  int alloc5 = 0 ;
13526  PyObject * obj0 = 0 ;
13527  PyObject * obj1 = 0 ;
13528  PyObject * obj2 = 0 ;
13529  PyObject * obj3 = 0 ;
13530  PyObject * obj4 = 0 ;
13531  libbgp::BgpOpenMessage *result = 0 ;
13532 
13533  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_BgpOpenMessage",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13534  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
13535  if (!SWIG_IsOK(res1)) {
13536  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpOpenMessage" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
13537  }
13538  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
13539  ecode2 = SWIG_AsVal_bool(obj1, &val2);
13540  if (!SWIG_IsOK(ecode2)) {
13541  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpOpenMessage" "', argument " "2"" of type '" "bool""'");
13542  }
13543  arg2 = static_cast< bool >(val2);
13544  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
13545  if (!SWIG_IsOK(ecode3)) {
13546  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BgpOpenMessage" "', argument " "3"" of type '" "uint16_t""'");
13547  }
13548  arg3 = static_cast< uint16_t >(val3);
13549  ecode4 = SWIG_AsVal_unsigned_SS_short(obj3, &val4);
13550  if (!SWIG_IsOK(ecode4)) {
13551  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BgpOpenMessage" "', argument " "4"" of type '" "uint16_t""'");
13552  }
13553  arg4 = static_cast< uint16_t >(val4);
13554  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
13555  if (!SWIG_IsOK(res5)) {
13556  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_BgpOpenMessage" "', argument " "5"" of type '" "char const *""'");
13557  }
13558  arg5 = reinterpret_cast< char * >(buf5);
13559  result = (libbgp::BgpOpenMessage *)new libbgp::BgpOpenMessage(arg1,arg2,arg3,arg4,(char const *)arg5);
13560  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpOpenMessage, SWIG_POINTER_NEW | 0 );
13561  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
13562  return resultobj;
13563 fail:
13564  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
13565  return NULL;
13566 }
13567 
13568 
13569 SWIGINTERN PyObject *_wrap_new_BgpOpenMessage(PyObject *self, PyObject *args) {
13570  Py_ssize_t argc;
13571  PyObject *argv[6] = {
13572  0
13573  };
13574  Py_ssize_t ii;
13575 
13576  if (!PyTuple_Check(args)) SWIG_fail;
13577  argc = args ? PyObject_Length(args) : 0;
13578  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
13579  argv[ii] = PyTuple_GET_ITEM(args,ii);
13580  }
13581  if (argc == 2) {
13582  int _v;
13583  void *vptr = 0;
13584  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
13585  _v = SWIG_CheckState(res);
13586  if (_v) {
13587  {
13588  int res = SWIG_AsVal_bool(argv[1], NULL);
13589  _v = SWIG_CheckState(res);
13590  }
13591  if (_v) {
13592  return _wrap_new_BgpOpenMessage__SWIG_0(self, args);
13593  }
13594  }
13595  }
13596  if (argc == 5) {
13597  int _v;
13598  void *vptr = 0;
13599  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
13600  _v = SWIG_CheckState(res);
13601  if (_v) {
13602  {
13603  int res = SWIG_AsVal_bool(argv[1], NULL);
13604  _v = SWIG_CheckState(res);
13605  }
13606  if (_v) {
13607  {
13608  int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
13609  _v = SWIG_CheckState(res);
13610  }
13611  if (_v) {
13612  {
13613  int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
13614  _v = SWIG_CheckState(res);
13615  }
13616  if (_v) {
13617  {
13618  int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
13619  _v = SWIG_CheckState(res);
13620  }
13621  if (_v) {
13622  return _wrap_new_BgpOpenMessage__SWIG_1(self, args);
13623  }
13624  }
13625  }
13626  }
13627  }
13628  }
13629  if (argc == 5) {
13630  int _v;
13631  void *vptr = 0;
13632  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
13633  _v = SWIG_CheckState(res);
13634  if (_v) {
13635  {
13636  int res = SWIG_AsVal_bool(argv[1], NULL);
13637  _v = SWIG_CheckState(res);
13638  }
13639  if (_v) {
13640  {
13641  int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
13642  _v = SWIG_CheckState(res);
13643  }
13644  if (_v) {
13645  {
13646  int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
13647  _v = SWIG_CheckState(res);
13648  }
13649  if (_v) {
13650  int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
13651  _v = SWIG_CheckState(res);
13652  if (_v) {
13653  return _wrap_new_BgpOpenMessage__SWIG_2(self, args);
13654  }
13655  }
13656  }
13657  }
13658  }
13659  }
13660 
13661 fail:
13662  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BgpOpenMessage'.\n"
13663  " Possible C/C++ prototypes are:\n"
13664  " libbgp::BgpOpenMessage::BgpOpenMessage(libbgp::BgpLogHandler *,bool)\n"
13665  " libbgp::BgpOpenMessage::BgpOpenMessage(libbgp::BgpLogHandler *,bool,uint16_t,uint16_t,uint32_t)\n"
13666  " libbgp::BgpOpenMessage::BgpOpenMessage(libbgp::BgpLogHandler *,bool,uint16_t,uint16_t,char const *)\n");
13667  return 0;
13668 }
13669 
13670 
13671 SWIGINTERN PyObject *_wrap_delete_BgpOpenMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13672  PyObject *resultobj = 0;
13674  void *argp1 = 0 ;
13675  int res1 = 0 ;
13676  PyObject * obj0 = 0 ;
13677 
13678  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpOpenMessage",&obj0)) SWIG_fail;
13679  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, SWIG_POINTER_DISOWN | 0 );
13680  if (!SWIG_IsOK(res1)) {
13681  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpOpenMessage" "', argument " "1"" of type '" "libbgp::BgpOpenMessage *""'");
13682  }
13683  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
13684  delete arg1;
13685  resultobj = SWIG_Py_Void();
13686  return resultobj;
13687 fail:
13688  return NULL;
13689 }
13690 
13691 
13692 SWIGINTERN PyObject *_wrap_BgpOpenMessage_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13693  PyObject *resultobj = 0;
13695  uint8_t arg2 ;
13696  void *argp1 = 0 ;
13697  int res1 = 0 ;
13698  unsigned char val2 ;
13699  int ecode2 = 0 ;
13700  PyObject * obj0 = 0 ;
13701  PyObject * obj1 = 0 ;
13702 
13703  if (!PyArg_ParseTuple(args,(char *)"OO:BgpOpenMessage_version_set",&obj0,&obj1)) SWIG_fail;
13704  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
13705  if (!SWIG_IsOK(res1)) {
13706  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_version_set" "', argument " "1"" of type '" "libbgp::BgpOpenMessage *""'");
13707  }
13708  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
13709  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
13710  if (!SWIG_IsOK(ecode2)) {
13711  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpOpenMessage_version_set" "', argument " "2"" of type '" "uint8_t""'");
13712  }
13713  arg2 = static_cast< uint8_t >(val2);
13714  if (arg1) (arg1)->version = arg2;
13715  resultobj = SWIG_Py_Void();
13716  return resultobj;
13717 fail:
13718  return NULL;
13719 }
13720 
13721 
13722 SWIGINTERN PyObject *_wrap_BgpOpenMessage_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13723  PyObject *resultobj = 0;
13725  void *argp1 = 0 ;
13726  int res1 = 0 ;
13727  PyObject * obj0 = 0 ;
13728  uint8_t result;
13729 
13730  if (!PyArg_ParseTuple(args,(char *)"O:BgpOpenMessage_version_get",&obj0)) SWIG_fail;
13731  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
13732  if (!SWIG_IsOK(res1)) {
13733  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_version_get" "', argument " "1"" of type '" "libbgp::BgpOpenMessage *""'");
13734  }
13735  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
13736  result = (uint8_t) ((arg1)->version);
13737  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13738  return resultobj;
13739 fail:
13740  return NULL;
13741 }
13742 
13743 
13744 SWIGINTERN PyObject *_wrap_BgpOpenMessage_my_asn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13745  PyObject *resultobj = 0;
13747  uint16_t arg2 ;
13748  void *argp1 = 0 ;
13749  int res1 = 0 ;
13750  unsigned short val2 ;
13751  int ecode2 = 0 ;
13752  PyObject * obj0 = 0 ;
13753  PyObject * obj1 = 0 ;
13754 
13755  if (!PyArg_ParseTuple(args,(char *)"OO:BgpOpenMessage_my_asn_set",&obj0,&obj1)) SWIG_fail;
13756  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
13757  if (!SWIG_IsOK(res1)) {
13758  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_my_asn_set" "', argument " "1"" of type '" "libbgp::BgpOpenMessage *""'");
13759  }
13760  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
13761  ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
13762  if (!SWIG_IsOK(ecode2)) {
13763  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpOpenMessage_my_asn_set" "', argument " "2"" of type '" "uint16_t""'");
13764  }
13765  arg2 = static_cast< uint16_t >(val2);
13766  if (arg1) (arg1)->my_asn = arg2;
13767  resultobj = SWIG_Py_Void();
13768  return resultobj;
13769 fail:
13770  return NULL;
13771 }
13772 
13773 
13774 SWIGINTERN PyObject *_wrap_BgpOpenMessage_my_asn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13775  PyObject *resultobj = 0;
13777  void *argp1 = 0 ;
13778  int res1 = 0 ;
13779  PyObject * obj0 = 0 ;
13780  uint16_t result;
13781 
13782  if (!PyArg_ParseTuple(args,(char *)"O:BgpOpenMessage_my_asn_get",&obj0)) SWIG_fail;
13783  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
13784  if (!SWIG_IsOK(res1)) {
13785  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_my_asn_get" "', argument " "1"" of type '" "libbgp::BgpOpenMessage *""'");
13786  }
13787  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
13788  result = (uint16_t) ((arg1)->my_asn);
13789  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
13790  return resultobj;
13791 fail:
13792  return NULL;
13793 }
13794 
13795 
13796 SWIGINTERN PyObject *_wrap_BgpOpenMessage_hold_time_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13797  PyObject *resultobj = 0;
13799  uint16_t arg2 ;
13800  void *argp1 = 0 ;
13801  int res1 = 0 ;
13802  unsigned short val2 ;
13803  int ecode2 = 0 ;
13804  PyObject * obj0 = 0 ;
13805  PyObject * obj1 = 0 ;
13806 
13807  if (!PyArg_ParseTuple(args,(char *)"OO:BgpOpenMessage_hold_time_set",&obj0,&obj1)) SWIG_fail;
13808  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
13809  if (!SWIG_IsOK(res1)) {
13810  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_hold_time_set" "', argument " "1"" of type '" "libbgp::BgpOpenMessage *""'");
13811  }
13812  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
13813  ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
13814  if (!SWIG_IsOK(ecode2)) {
13815  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpOpenMessage_hold_time_set" "', argument " "2"" of type '" "uint16_t""'");
13816  }
13817  arg2 = static_cast< uint16_t >(val2);
13818  if (arg1) (arg1)->hold_time = arg2;
13819  resultobj = SWIG_Py_Void();
13820  return resultobj;
13821 fail:
13822  return NULL;
13823 }
13824 
13825 
13826 SWIGINTERN PyObject *_wrap_BgpOpenMessage_hold_time_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13827  PyObject *resultobj = 0;
13829  void *argp1 = 0 ;
13830  int res1 = 0 ;
13831  PyObject * obj0 = 0 ;
13832  uint16_t result;
13833 
13834  if (!PyArg_ParseTuple(args,(char *)"O:BgpOpenMessage_hold_time_get",&obj0)) SWIG_fail;
13835  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
13836  if (!SWIG_IsOK(res1)) {
13837  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_hold_time_get" "', argument " "1"" of type '" "libbgp::BgpOpenMessage *""'");
13838  }
13839  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
13840  result = (uint16_t) ((arg1)->hold_time);
13841  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
13842  return resultobj;
13843 fail:
13844  return NULL;
13845 }
13846 
13847 
13848 SWIGINTERN PyObject *_wrap_BgpOpenMessage_bgp_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13849  PyObject *resultobj = 0;
13851  uint32_t arg2 ;
13852  void *argp1 = 0 ;
13853  int res1 = 0 ;
13854  unsigned int val2 ;
13855  int ecode2 = 0 ;
13856  PyObject * obj0 = 0 ;
13857  PyObject * obj1 = 0 ;
13858 
13859  if (!PyArg_ParseTuple(args,(char *)"OO:BgpOpenMessage_bgp_id_set",&obj0,&obj1)) SWIG_fail;
13860  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
13861  if (!SWIG_IsOK(res1)) {
13862  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_bgp_id_set" "', argument " "1"" of type '" "libbgp::BgpOpenMessage *""'");
13863  }
13864  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
13865  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
13866  if (!SWIG_IsOK(ecode2)) {
13867  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpOpenMessage_bgp_id_set" "', argument " "2"" of type '" "uint32_t""'");
13868  }
13869  arg2 = static_cast< uint32_t >(val2);
13870  if (arg1) (arg1)->bgp_id = arg2;
13871  resultobj = SWIG_Py_Void();
13872  return resultobj;
13873 fail:
13874  return NULL;
13875 }
13876 
13877 
13878 SWIGINTERN PyObject *_wrap_BgpOpenMessage_bgp_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13879  PyObject *resultobj = 0;
13881  void *argp1 = 0 ;
13882  int res1 = 0 ;
13883  PyObject * obj0 = 0 ;
13884  uint32_t result;
13885 
13886  if (!PyArg_ParseTuple(args,(char *)"O:BgpOpenMessage_bgp_id_get",&obj0)) SWIG_fail;
13887  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
13888  if (!SWIG_IsOK(res1)) {
13889  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_bgp_id_get" "', argument " "1"" of type '" "libbgp::BgpOpenMessage *""'");
13890  }
13891  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
13892  result = (uint32_t) ((arg1)->bgp_id);
13893  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
13894  return resultobj;
13895 fail:
13896  return NULL;
13897 }
13898 
13899 
13900 SWIGINTERN PyObject *_wrap_BgpOpenMessage_setAsn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13901  PyObject *resultobj = 0;
13903  uint32_t arg2 ;
13904  void *argp1 = 0 ;
13905  int res1 = 0 ;
13906  unsigned int val2 ;
13907  int ecode2 = 0 ;
13908  PyObject * obj0 = 0 ;
13909  PyObject * obj1 = 0 ;
13910  bool result;
13911 
13912  if (!PyArg_ParseTuple(args,(char *)"OO:BgpOpenMessage_setAsn",&obj0,&obj1)) SWIG_fail;
13913  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
13914  if (!SWIG_IsOK(res1)) {
13915  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_setAsn" "', argument " "1"" of type '" "libbgp::BgpOpenMessage *""'");
13916  }
13917  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
13918  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
13919  if (!SWIG_IsOK(ecode2)) {
13920  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpOpenMessage_setAsn" "', argument " "2"" of type '" "uint32_t""'");
13921  }
13922  arg2 = static_cast< uint32_t >(val2);
13923  result = (bool)(arg1)->setAsn(arg2);
13924  resultobj = SWIG_From_bool(static_cast< bool >(result));
13925  return resultobj;
13926 fail:
13927  return NULL;
13928 }
13929 
13930 
13931 SWIGINTERN PyObject *_wrap_BgpOpenMessage_getAsn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13932  PyObject *resultobj = 0;
13934  void *argp1 = 0 ;
13935  int res1 = 0 ;
13936  PyObject * obj0 = 0 ;
13937  uint32_t result;
13938 
13939  if (!PyArg_ParseTuple(args,(char *)"O:BgpOpenMessage_getAsn",&obj0)) SWIG_fail;
13940  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
13941  if (!SWIG_IsOK(res1)) {
13942  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_getAsn" "', argument " "1"" of type '" "libbgp::BgpOpenMessage const *""'");
13943  }
13944  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
13945  result = (uint32_t)((libbgp::BgpOpenMessage const *)arg1)->getAsn();
13946  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
13947  return resultobj;
13948 fail:
13949  return NULL;
13950 }
13951 
13952 
13953 SWIGINTERN PyObject *_wrap_BgpOpenMessage_hasCapability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13954  PyObject *resultobj = 0;
13956  uint8_t arg2 ;
13957  void *argp1 = 0 ;
13958  int res1 = 0 ;
13959  unsigned char val2 ;
13960  int ecode2 = 0 ;
13961  PyObject * obj0 = 0 ;
13962  PyObject * obj1 = 0 ;
13963  bool result;
13964 
13965  if (!PyArg_ParseTuple(args,(char *)"OO:BgpOpenMessage_hasCapability",&obj0,&obj1)) SWIG_fail;
13966  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
13967  if (!SWIG_IsOK(res1)) {
13968  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_hasCapability" "', argument " "1"" of type '" "libbgp::BgpOpenMessage const *""'");
13969  }
13970  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
13971  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
13972  if (!SWIG_IsOK(ecode2)) {
13973  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpOpenMessage_hasCapability" "', argument " "2"" of type '" "uint8_t""'");
13974  }
13975  arg2 = static_cast< uint8_t >(val2);
13976  result = (bool)((libbgp::BgpOpenMessage const *)arg1)->hasCapability(arg2);
13977  resultobj = SWIG_From_bool(static_cast< bool >(result));
13978  return resultobj;
13979 fail:
13980  return NULL;
13981 }
13982 
13983 
13984 SWIGINTERN PyObject *_wrap_BgpOpenMessage_addCapability(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13985  PyObject *resultobj = 0;
13987  SwigValueWrapper< std::shared_ptr< libbgp::BgpCapability > > arg2 ;
13988  void *argp1 = 0 ;
13989  int res1 = 0 ;
13990  void *argp2 ;
13991  int res2 = 0 ;
13992  PyObject * obj0 = 0 ;
13993  PyObject * obj1 = 0 ;
13994  bool result;
13995 
13996  if (!PyArg_ParseTuple(args,(char *)"OO:BgpOpenMessage_addCapability",&obj0,&obj1)) SWIG_fail;
13997  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
13998  if (!SWIG_IsOK(res1)) {
13999  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_addCapability" "', argument " "1"" of type '" "libbgp::BgpOpenMessage *""'");
14000  }
14001  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
14002  {
14003  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__shared_ptrT_libbgp__BgpCapability_t, 0 | 0);
14004  if (!SWIG_IsOK(res2)) {
14005  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpOpenMessage_addCapability" "', argument " "2"" of type '" "std::shared_ptr< libbgp::BgpCapability >""'");
14006  }
14007  if (!argp2) {
14008  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpOpenMessage_addCapability" "', argument " "2"" of type '" "std::shared_ptr< libbgp::BgpCapability >""'");
14009  } else {
14010  std::shared_ptr< libbgp::BgpCapability > * temp = reinterpret_cast< std::shared_ptr< libbgp::BgpCapability > * >(argp2);
14011  arg2 = *temp;
14012  if (SWIG_IsNewObj(res2)) delete temp;
14013  }
14014  }
14015  result = (bool)(arg1)->addCapability(arg2);
14016  resultobj = SWIG_From_bool(static_cast< bool >(result));
14017  return resultobj;
14018 fail:
14019  return NULL;
14020 }
14021 
14022 
14023 SWIGINTERN PyObject *_wrap_BgpOpenMessage_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14024  PyObject *resultobj = 0;
14026  size_t arg2 ;
14027  uint8_t **arg3 = (uint8_t **) 0 ;
14028  size_t *arg4 = (size_t *) 0 ;
14029  void *argp1 = 0 ;
14030  int res1 = 0 ;
14031  size_t val2 ;
14032  int ecode2 = 0 ;
14033  void *argp3 = 0 ;
14034  int res3 = 0 ;
14035  void *argp4 = 0 ;
14036  int res4 = 0 ;
14037  PyObject * obj0 = 0 ;
14038  PyObject * obj1 = 0 ;
14039  PyObject * obj2 = 0 ;
14040  PyObject * obj3 = 0 ;
14041  ssize_t result;
14042 
14043  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpOpenMessage_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14044  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
14045  if (!SWIG_IsOK(res1)) {
14046  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_doPrint" "', argument " "1"" of type '" "libbgp::BgpOpenMessage const *""'");
14047  }
14048  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
14049  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
14050  if (!SWIG_IsOK(ecode2)) {
14051  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpOpenMessage_doPrint" "', argument " "2"" of type '" "size_t""'");
14052  }
14053  arg2 = static_cast< size_t >(val2);
14054  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
14055  if (!SWIG_IsOK(res3)) {
14056  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpOpenMessage_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
14057  }
14058  arg3 = reinterpret_cast< uint8_t ** >(argp3);
14059  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
14060  if (!SWIG_IsOK(res4)) {
14061  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpOpenMessage_doPrint" "', argument " "4"" of type '" "size_t *""'");
14062  }
14063  arg4 = reinterpret_cast< size_t * >(argp4);
14064  result = ((libbgp::BgpOpenMessage const *)arg1)->doPrint(arg2,arg3,arg4);
14065  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
14066  return resultobj;
14067 fail:
14068  return NULL;
14069 }
14070 
14071 
14072 SWIGINTERN PyObject *_wrap_BgpOpenMessage_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14073  PyObject *resultobj = 0;
14075  uint8_t *arg2 = (uint8_t *) 0 ;
14076  size_t arg3 ;
14077  void *argp1 = 0 ;
14078  int res1 = 0 ;
14079  void *argp2 = 0 ;
14080  int res2 = 0 ;
14081  size_t val3 ;
14082  int ecode3 = 0 ;
14083  PyObject * obj0 = 0 ;
14084  PyObject * obj1 = 0 ;
14085  PyObject * obj2 = 0 ;
14086  ssize_t result;
14087 
14088  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpOpenMessage_parse",&obj0,&obj1,&obj2)) SWIG_fail;
14089  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
14090  if (!SWIG_IsOK(res1)) {
14091  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_parse" "', argument " "1"" of type '" "libbgp::BgpOpenMessage *""'");
14092  }
14093  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
14094  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
14095  if (!SWIG_IsOK(res2)) {
14096  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpOpenMessage_parse" "', argument " "2"" of type '" "uint8_t const *""'");
14097  }
14098  arg2 = reinterpret_cast< uint8_t * >(argp2);
14099  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
14100  if (!SWIG_IsOK(ecode3)) {
14101  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpOpenMessage_parse" "', argument " "3"" of type '" "size_t""'");
14102  }
14103  arg3 = static_cast< size_t >(val3);
14104  result = (arg1)->parse((uint8_t const *)arg2,arg3);
14105  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
14106  return resultobj;
14107 fail:
14108  return NULL;
14109 }
14110 
14111 
14112 SWIGINTERN PyObject *_wrap_BgpOpenMessage_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14113  PyObject *resultobj = 0;
14115  uint8_t *arg2 = (uint8_t *) 0 ;
14116  size_t arg3 ;
14117  void *argp1 = 0 ;
14118  int res1 = 0 ;
14119  void *argp2 = 0 ;
14120  int res2 = 0 ;
14121  size_t val3 ;
14122  int ecode3 = 0 ;
14123  PyObject * obj0 = 0 ;
14124  PyObject * obj1 = 0 ;
14125  PyObject * obj2 = 0 ;
14126  ssize_t result;
14127 
14128  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpOpenMessage_write",&obj0,&obj1,&obj2)) SWIG_fail;
14129  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
14130  if (!SWIG_IsOK(res1)) {
14131  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_write" "', argument " "1"" of type '" "libbgp::BgpOpenMessage const *""'");
14132  }
14133  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
14134  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
14135  if (!SWIG_IsOK(res2)) {
14136  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpOpenMessage_write" "', argument " "2"" of type '" "uint8_t *""'");
14137  }
14138  arg2 = reinterpret_cast< uint8_t * >(argp2);
14139  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
14140  if (!SWIG_IsOK(ecode3)) {
14141  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpOpenMessage_write" "', argument " "3"" of type '" "size_t""'");
14142  }
14143  arg3 = static_cast< size_t >(val3);
14144  result = ((libbgp::BgpOpenMessage const *)arg1)->write(arg2,arg3);
14145  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
14146  return resultobj;
14147 fail:
14148  return NULL;
14149 }
14150 
14151 
14152 SWIGINTERN PyObject *_wrap_BgpOpenMessage_getCapabilities(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14153  PyObject *resultobj = 0;
14155  void *argp1 = 0 ;
14156  int res1 = 0 ;
14157  PyObject * obj0 = 0 ;
14158  std::vector< std::shared_ptr< libbgp::BgpCapability > > *result = 0 ;
14159 
14160  if (!PyArg_ParseTuple(args,(char *)"O:BgpOpenMessage_getCapabilities",&obj0)) SWIG_fail;
14161  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOpenMessage, 0 | 0 );
14162  if (!SWIG_IsOK(res1)) {
14163  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOpenMessage_getCapabilities" "', argument " "1"" of type '" "libbgp::BgpOpenMessage const *""'");
14164  }
14165  arg1 = reinterpret_cast< libbgp::BgpOpenMessage * >(argp1);
14166  result = (std::vector< std::shared_ptr< libbgp::BgpCapability > > *) &((libbgp::BgpOpenMessage const *)arg1)->getCapabilities();
14167  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpCapability_t_t, 0 | 0 );
14168  return resultobj;
14169 fail:
14170  return NULL;
14171 }
14172 
14173 
14174 SWIGINTERN PyObject *BgpOpenMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14175  PyObject *obj;
14176  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
14177  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpOpenMessage, SWIG_NewClientData(obj));
14178  return SWIG_Py_Void();
14179 }
14180 
14181 SWIGINTERN PyObject *_wrap_BgpOutHandler_handleOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14182  PyObject *resultobj = 0;
14184  uint8_t *arg2 = (uint8_t *) 0 ;
14185  size_t arg3 ;
14186  void *argp1 = 0 ;
14187  int res1 = 0 ;
14188  void *argp2 = 0 ;
14189  int res2 = 0 ;
14190  size_t val3 ;
14191  int ecode3 = 0 ;
14192  PyObject * obj0 = 0 ;
14193  PyObject * obj1 = 0 ;
14194  PyObject * obj2 = 0 ;
14195  bool result;
14196 
14197  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpOutHandler_handleOut",&obj0,&obj1,&obj2)) SWIG_fail;
14198  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOutHandler, 0 | 0 );
14199  if (!SWIG_IsOK(res1)) {
14200  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOutHandler_handleOut" "', argument " "1"" of type '" "libbgp::BgpOutHandler *""'");
14201  }
14202  arg1 = reinterpret_cast< libbgp::BgpOutHandler * >(argp1);
14203  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
14204  if (!SWIG_IsOK(res2)) {
14205  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpOutHandler_handleOut" "', argument " "2"" of type '" "uint8_t const *""'");
14206  }
14207  arg2 = reinterpret_cast< uint8_t * >(argp2);
14208  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
14209  if (!SWIG_IsOK(ecode3)) {
14210  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpOutHandler_handleOut" "', argument " "3"" of type '" "size_t""'");
14211  }
14212  arg3 = static_cast< size_t >(val3);
14213  result = (bool)(arg1)->handleOut((uint8_t const *)arg2,arg3);
14214  resultobj = SWIG_From_bool(static_cast< bool >(result));
14215  return resultobj;
14216 fail:
14217  return NULL;
14218 }
14219 
14220 
14221 SWIGINTERN PyObject *_wrap_BgpOutHandler_notifyStateChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14222  PyObject *resultobj = 0;
14224  int arg2 ;
14225  int arg3 ;
14226  void *argp1 = 0 ;
14227  int res1 = 0 ;
14228  int val2 ;
14229  int ecode2 = 0 ;
14230  int val3 ;
14231  int ecode3 = 0 ;
14232  PyObject * obj0 = 0 ;
14233  PyObject * obj1 = 0 ;
14234  PyObject * obj2 = 0 ;
14235 
14236  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpOutHandler_notifyStateChange",&obj0,&obj1,&obj2)) SWIG_fail;
14237  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOutHandler, 0 | 0 );
14238  if (!SWIG_IsOK(res1)) {
14239  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpOutHandler_notifyStateChange" "', argument " "1"" of type '" "libbgp::BgpOutHandler *""'");
14240  }
14241  arg1 = reinterpret_cast< libbgp::BgpOutHandler * >(argp1);
14242  ecode2 = SWIG_AsVal_int(obj1, &val2);
14243  if (!SWIG_IsOK(ecode2)) {
14244  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpOutHandler_notifyStateChange" "', argument " "2"" of type '" "int""'");
14245  }
14246  arg2 = static_cast< int >(val2);
14247  ecode3 = SWIG_AsVal_int(obj2, &val3);
14248  if (!SWIG_IsOK(ecode3)) {
14249  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpOutHandler_notifyStateChange" "', argument " "3"" of type '" "int""'");
14250  }
14251  arg3 = static_cast< int >(val3);
14252  (arg1)->notifyStateChange(arg2,arg3);
14253  resultobj = SWIG_Py_Void();
14254  return resultobj;
14255 fail:
14256  return NULL;
14257 }
14258 
14259 
14260 SWIGINTERN PyObject *_wrap_delete_BgpOutHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14261  PyObject *resultobj = 0;
14263  void *argp1 = 0 ;
14264  int res1 = 0 ;
14265  PyObject * obj0 = 0 ;
14266 
14267  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpOutHandler",&obj0)) SWIG_fail;
14268  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpOutHandler, SWIG_POINTER_DISOWN | 0 );
14269  if (!SWIG_IsOK(res1)) {
14270  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpOutHandler" "', argument " "1"" of type '" "libbgp::BgpOutHandler *""'");
14271  }
14272  arg1 = reinterpret_cast< libbgp::BgpOutHandler * >(argp1);
14273  delete arg1;
14274  resultobj = SWIG_Py_Void();
14275  return resultobj;
14276 fail:
14277  return NULL;
14278 }
14279 
14280 
14281 SWIGINTERN PyObject *BgpOutHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14282  PyObject *obj;
14283  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
14284  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpOutHandler, SWIG_NewClientData(obj));
14285  return SWIG_Py_Void();
14286 }
14287 
14288 SWIGINTERN PyObject *_wrap_new_FdOutHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14289  PyObject *resultobj = 0;
14290  int arg1 ;
14291  int val1 ;
14292  int ecode1 = 0 ;
14293  PyObject * obj0 = 0 ;
14294  libbgp::FdOutHandler *result = 0 ;
14295 
14296  if (!PyArg_ParseTuple(args,(char *)"O:new_FdOutHandler",&obj0)) SWIG_fail;
14297  ecode1 = SWIG_AsVal_int(obj0, &val1);
14298  if (!SWIG_IsOK(ecode1)) {
14299  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FdOutHandler" "', argument " "1"" of type '" "int""'");
14300  }
14301  arg1 = static_cast< int >(val1);
14302  result = (libbgp::FdOutHandler *)new libbgp::FdOutHandler(arg1);
14303  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__FdOutHandler, SWIG_POINTER_NEW | 0 );
14304  return resultobj;
14305 fail:
14306  return NULL;
14307 }
14308 
14309 
14310 SWIGINTERN PyObject *_wrap_FdOutHandler_handleOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14311  PyObject *resultobj = 0;
14313  uint8_t *arg2 = (uint8_t *) 0 ;
14314  size_t arg3 ;
14315  void *argp1 = 0 ;
14316  int res1 = 0 ;
14317  void *argp2 = 0 ;
14318  int res2 = 0 ;
14319  size_t val3 ;
14320  int ecode3 = 0 ;
14321  PyObject * obj0 = 0 ;
14322  PyObject * obj1 = 0 ;
14323  PyObject * obj2 = 0 ;
14324  bool result;
14325 
14326  if (!PyArg_ParseTuple(args,(char *)"OOO:FdOutHandler_handleOut",&obj0,&obj1,&obj2)) SWIG_fail;
14327  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__FdOutHandler, 0 | 0 );
14328  if (!SWIG_IsOK(res1)) {
14329  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FdOutHandler_handleOut" "', argument " "1"" of type '" "libbgp::FdOutHandler *""'");
14330  }
14331  arg1 = reinterpret_cast< libbgp::FdOutHandler * >(argp1);
14332  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
14333  if (!SWIG_IsOK(res2)) {
14334  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FdOutHandler_handleOut" "', argument " "2"" of type '" "uint8_t const *""'");
14335  }
14336  arg2 = reinterpret_cast< uint8_t * >(argp2);
14337  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
14338  if (!SWIG_IsOK(ecode3)) {
14339  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FdOutHandler_handleOut" "', argument " "3"" of type '" "size_t""'");
14340  }
14341  arg3 = static_cast< size_t >(val3);
14342  result = (bool)(arg1)->handleOut((uint8_t const *)arg2,arg3);
14343  resultobj = SWIG_From_bool(static_cast< bool >(result));
14344  return resultobj;
14345 fail:
14346  return NULL;
14347 }
14348 
14349 
14350 SWIGINTERN PyObject *_wrap_delete_FdOutHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14351  PyObject *resultobj = 0;
14353  void *argp1 = 0 ;
14354  int res1 = 0 ;
14355  PyObject * obj0 = 0 ;
14356 
14357  if (!PyArg_ParseTuple(args,(char *)"O:delete_FdOutHandler",&obj0)) SWIG_fail;
14358  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__FdOutHandler, SWIG_POINTER_DISOWN | 0 );
14359  if (!SWIG_IsOK(res1)) {
14360  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FdOutHandler" "', argument " "1"" of type '" "libbgp::FdOutHandler *""'");
14361  }
14362  arg1 = reinterpret_cast< libbgp::FdOutHandler * >(argp1);
14363  delete arg1;
14364  resultobj = SWIG_Py_Void();
14365  return resultobj;
14366 fail:
14367  return NULL;
14368 }
14369 
14370 
14371 SWIGINTERN PyObject *FdOutHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14372  PyObject *obj;
14373  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
14374  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__FdOutHandler, SWIG_NewClientData(obj));
14375  return SWIG_Py_Void();
14376 }
14377 
14378 SWIGINTERN PyObject *_wrap_new_BgpPacket__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14379  PyObject *resultobj = 0;
14381  bool arg2 ;
14382  libbgp::BgpMessage *arg3 = (libbgp::BgpMessage *) 0 ;
14383  void *argp1 = 0 ;
14384  int res1 = 0 ;
14385  bool val2 ;
14386  int ecode2 = 0 ;
14387  void *argp3 = 0 ;
14388  int res3 = 0 ;
14389  PyObject * obj0 = 0 ;
14390  PyObject * obj1 = 0 ;
14391  PyObject * obj2 = 0 ;
14392  libbgp::BgpPacket *result = 0 ;
14393 
14394  if (!PyArg_ParseTuple(args,(char *)"OOO:new_BgpPacket",&obj0,&obj1,&obj2)) SWIG_fail;
14395  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
14396  if (!SWIG_IsOK(res1)) {
14397  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPacket" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
14398  }
14399  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
14400  ecode2 = SWIG_AsVal_bool(obj1, &val2);
14401  if (!SWIG_IsOK(ecode2)) {
14402  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpPacket" "', argument " "2"" of type '" "bool""'");
14403  }
14404  arg2 = static_cast< bool >(val2);
14405  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_libbgp__BgpMessage, 0 | 0 );
14406  if (!SWIG_IsOK(res3)) {
14407  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BgpPacket" "', argument " "3"" of type '" "libbgp::BgpMessage const *""'");
14408  }
14409  arg3 = reinterpret_cast< libbgp::BgpMessage * >(argp3);
14410  result = (libbgp::BgpPacket *)new libbgp::BgpPacket(arg1,arg2,(libbgp::BgpMessage const *)arg3);
14411  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPacket, SWIG_POINTER_NEW | 0 );
14412  return resultobj;
14413 fail:
14414  return NULL;
14415 }
14416 
14417 
14418 SWIGINTERN PyObject *_wrap_new_BgpPacket__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14419  PyObject *resultobj = 0;
14421  bool arg2 ;
14422  void *argp1 = 0 ;
14423  int res1 = 0 ;
14424  bool val2 ;
14425  int ecode2 = 0 ;
14426  PyObject * obj0 = 0 ;
14427  PyObject * obj1 = 0 ;
14428  libbgp::BgpPacket *result = 0 ;
14429 
14430  if (!PyArg_ParseTuple(args,(char *)"OO:new_BgpPacket",&obj0,&obj1)) SWIG_fail;
14431  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
14432  if (!SWIG_IsOK(res1)) {
14433  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPacket" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
14434  }
14435  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
14436  ecode2 = SWIG_AsVal_bool(obj1, &val2);
14437  if (!SWIG_IsOK(ecode2)) {
14438  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpPacket" "', argument " "2"" of type '" "bool""'");
14439  }
14440  arg2 = static_cast< bool >(val2);
14441  result = (libbgp::BgpPacket *)new libbgp::BgpPacket(arg1,arg2);
14442  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPacket, SWIG_POINTER_NEW | 0 );
14443  return resultobj;
14444 fail:
14445  return NULL;
14446 }
14447 
14448 
14449 SWIGINTERN PyObject *_wrap_new_BgpPacket(PyObject *self, PyObject *args) {
14450  Py_ssize_t argc;
14451  PyObject *argv[4] = {
14452  0
14453  };
14454  Py_ssize_t ii;
14455 
14456  if (!PyTuple_Check(args)) SWIG_fail;
14457  argc = args ? PyObject_Length(args) : 0;
14458  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
14459  argv[ii] = PyTuple_GET_ITEM(args,ii);
14460  }
14461  if (argc == 2) {
14462  int _v;
14463  void *vptr = 0;
14464  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
14465  _v = SWIG_CheckState(res);
14466  if (_v) {
14467  {
14468  int res = SWIG_AsVal_bool(argv[1], NULL);
14469  _v = SWIG_CheckState(res);
14470  }
14471  if (_v) {
14472  return _wrap_new_BgpPacket__SWIG_1(self, args);
14473  }
14474  }
14475  }
14476  if (argc == 3) {
14477  int _v;
14478  void *vptr = 0;
14479  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
14480  _v = SWIG_CheckState(res);
14481  if (_v) {
14482  {
14483  int res = SWIG_AsVal_bool(argv[1], NULL);
14484  _v = SWIG_CheckState(res);
14485  }
14486  if (_v) {
14487  void *vptr = 0;
14488  int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_libbgp__BgpMessage, 0);
14489  _v = SWIG_CheckState(res);
14490  if (_v) {
14491  return _wrap_new_BgpPacket__SWIG_0(self, args);
14492  }
14493  }
14494  }
14495  }
14496 
14497 fail:
14498  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BgpPacket'.\n"
14499  " Possible C/C++ prototypes are:\n"
14500  " libbgp::BgpPacket::BgpPacket(libbgp::BgpLogHandler *,bool,libbgp::BgpMessage const *)\n"
14501  " libbgp::BgpPacket::BgpPacket(libbgp::BgpLogHandler *,bool)\n");
14502  return 0;
14503 }
14504 
14505 
14506 SWIGINTERN PyObject *_wrap_delete_BgpPacket(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14507  PyObject *resultobj = 0;
14508  libbgp::BgpPacket *arg1 = (libbgp::BgpPacket *) 0 ;
14509  void *argp1 = 0 ;
14510  int res1 = 0 ;
14511  PyObject * obj0 = 0 ;
14512 
14513  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPacket",&obj0)) SWIG_fail;
14514  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPacket, SWIG_POINTER_DISOWN | 0 );
14515  if (!SWIG_IsOK(res1)) {
14516  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPacket" "', argument " "1"" of type '" "libbgp::BgpPacket *""'");
14517  }
14518  arg1 = reinterpret_cast< libbgp::BgpPacket * >(argp1);
14519  delete arg1;
14520  resultobj = SWIG_Py_Void();
14521  return resultobj;
14522 fail:
14523  return NULL;
14524 }
14525 
14526 
14527 SWIGINTERN PyObject *_wrap_BgpPacket_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14528  PyObject *resultobj = 0;
14529  libbgp::BgpPacket *arg1 = (libbgp::BgpPacket *) 0 ;
14530  size_t arg2 ;
14531  uint8_t **arg3 = (uint8_t **) 0 ;
14532  size_t *arg4 = (size_t *) 0 ;
14533  void *argp1 = 0 ;
14534  int res1 = 0 ;
14535  size_t val2 ;
14536  int ecode2 = 0 ;
14537  void *argp3 = 0 ;
14538  int res3 = 0 ;
14539  void *argp4 = 0 ;
14540  int res4 = 0 ;
14541  PyObject * obj0 = 0 ;
14542  PyObject * obj1 = 0 ;
14543  PyObject * obj2 = 0 ;
14544  PyObject * obj3 = 0 ;
14545  ssize_t result;
14546 
14547  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPacket_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14548  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPacket, 0 | 0 );
14549  if (!SWIG_IsOK(res1)) {
14550  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPacket_doPrint" "', argument " "1"" of type '" "libbgp::BgpPacket const *""'");
14551  }
14552  arg1 = reinterpret_cast< libbgp::BgpPacket * >(argp1);
14553  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
14554  if (!SWIG_IsOK(ecode2)) {
14555  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPacket_doPrint" "', argument " "2"" of type '" "size_t""'");
14556  }
14557  arg2 = static_cast< size_t >(val2);
14558  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
14559  if (!SWIG_IsOK(res3)) {
14560  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPacket_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
14561  }
14562  arg3 = reinterpret_cast< uint8_t ** >(argp3);
14563  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
14564  if (!SWIG_IsOK(res4)) {
14565  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPacket_doPrint" "', argument " "4"" of type '" "size_t *""'");
14566  }
14567  arg4 = reinterpret_cast< size_t * >(argp4);
14568  result = ((libbgp::BgpPacket const *)arg1)->doPrint(arg2,arg3,arg4);
14569  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
14570  return resultobj;
14571 fail:
14572  return NULL;
14573 }
14574 
14575 
14576 SWIGINTERN PyObject *_wrap_BgpPacket_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14577  PyObject *resultobj = 0;
14578  libbgp::BgpPacket *arg1 = (libbgp::BgpPacket *) 0 ;
14579  uint8_t *arg2 = (uint8_t *) 0 ;
14580  size_t arg3 ;
14581  void *argp1 = 0 ;
14582  int res1 = 0 ;
14583  void *argp2 = 0 ;
14584  int res2 = 0 ;
14585  size_t val3 ;
14586  int ecode3 = 0 ;
14587  PyObject * obj0 = 0 ;
14588  PyObject * obj1 = 0 ;
14589  PyObject * obj2 = 0 ;
14590  ssize_t result;
14591 
14592  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPacket_parse",&obj0,&obj1,&obj2)) SWIG_fail;
14593  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPacket, 0 | 0 );
14594  if (!SWIG_IsOK(res1)) {
14595  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPacket_parse" "', argument " "1"" of type '" "libbgp::BgpPacket *""'");
14596  }
14597  arg1 = reinterpret_cast< libbgp::BgpPacket * >(argp1);
14598  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
14599  if (!SWIG_IsOK(res2)) {
14600  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPacket_parse" "', argument " "2"" of type '" "uint8_t const *""'");
14601  }
14602  arg2 = reinterpret_cast< uint8_t * >(argp2);
14603  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
14604  if (!SWIG_IsOK(ecode3)) {
14605  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPacket_parse" "', argument " "3"" of type '" "size_t""'");
14606  }
14607  arg3 = static_cast< size_t >(val3);
14608  result = (arg1)->parse((uint8_t const *)arg2,arg3);
14609  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
14610  return resultobj;
14611 fail:
14612  return NULL;
14613 }
14614 
14615 
14616 SWIGINTERN PyObject *_wrap_BgpPacket_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14617  PyObject *resultobj = 0;
14618  libbgp::BgpPacket *arg1 = (libbgp::BgpPacket *) 0 ;
14619  uint8_t *arg2 = (uint8_t *) 0 ;
14620  size_t arg3 ;
14621  void *argp1 = 0 ;
14622  int res1 = 0 ;
14623  void *argp2 = 0 ;
14624  int res2 = 0 ;
14625  size_t val3 ;
14626  int ecode3 = 0 ;
14627  PyObject * obj0 = 0 ;
14628  PyObject * obj1 = 0 ;
14629  PyObject * obj2 = 0 ;
14630  ssize_t result;
14631 
14632  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPacket_write",&obj0,&obj1,&obj2)) SWIG_fail;
14633  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPacket, 0 | 0 );
14634  if (!SWIG_IsOK(res1)) {
14635  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPacket_write" "', argument " "1"" of type '" "libbgp::BgpPacket const *""'");
14636  }
14637  arg1 = reinterpret_cast< libbgp::BgpPacket * >(argp1);
14638  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
14639  if (!SWIG_IsOK(res2)) {
14640  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPacket_write" "', argument " "2"" of type '" "uint8_t *""'");
14641  }
14642  arg2 = reinterpret_cast< uint8_t * >(argp2);
14643  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
14644  if (!SWIG_IsOK(ecode3)) {
14645  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPacket_write" "', argument " "3"" of type '" "size_t""'");
14646  }
14647  arg3 = static_cast< size_t >(val3);
14648  result = ((libbgp::BgpPacket const *)arg1)->write(arg2,arg3);
14649  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
14650  return resultobj;
14651 fail:
14652  return NULL;
14653 }
14654 
14655 
14656 SWIGINTERN PyObject *_wrap_BgpPacket_getMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14657  PyObject *resultobj = 0;
14658  libbgp::BgpPacket *arg1 = (libbgp::BgpPacket *) 0 ;
14659  void *argp1 = 0 ;
14660  int res1 = 0 ;
14661  PyObject * obj0 = 0 ;
14662  libbgp::BgpMessage *result = 0 ;
14663 
14664  if (!PyArg_ParseTuple(args,(char *)"O:BgpPacket_getMessage",&obj0)) SWIG_fail;
14665  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPacket, 0 | 0 );
14666  if (!SWIG_IsOK(res1)) {
14667  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPacket_getMessage" "', argument " "1"" of type '" "libbgp::BgpPacket const *""'");
14668  }
14669  arg1 = reinterpret_cast< libbgp::BgpPacket * >(argp1);
14670  result = (libbgp::BgpMessage *)((libbgp::BgpPacket const *)arg1)->getMessage();
14671  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpMessage, 0 | 0 );
14672  return resultobj;
14673 fail:
14674  return NULL;
14675 }
14676 
14677 
14678 SWIGINTERN PyObject *BgpPacket_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14679  PyObject *obj;
14680  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
14681  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPacket, SWIG_NewClientData(obj));
14682  return SWIG_Py_Void();
14683 }
14684 
14685 SWIGINTERN PyObject *_wrap_BgpPathAttrib_optional_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14686  PyObject *resultobj = 0;
14688  bool arg2 ;
14689  void *argp1 = 0 ;
14690  int res1 = 0 ;
14691  bool val2 ;
14692  int ecode2 = 0 ;
14693  PyObject * obj0 = 0 ;
14694  PyObject * obj1 = 0 ;
14695 
14696  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttrib_optional_set",&obj0,&obj1)) SWIG_fail;
14697  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
14698  if (!SWIG_IsOK(res1)) {
14699  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_optional_set" "', argument " "1"" of type '" "libbgp::BgpPathAttrib *""'");
14700  }
14701  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
14702  ecode2 = SWIG_AsVal_bool(obj1, &val2);
14703  if (!SWIG_IsOK(ecode2)) {
14704  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttrib_optional_set" "', argument " "2"" of type '" "bool""'");
14705  }
14706  arg2 = static_cast< bool >(val2);
14707  if (arg1) (arg1)->optional = arg2;
14708  resultobj = SWIG_Py_Void();
14709  return resultobj;
14710 fail:
14711  return NULL;
14712 }
14713 
14714 
14715 SWIGINTERN PyObject *_wrap_BgpPathAttrib_optional_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14716  PyObject *resultobj = 0;
14718  void *argp1 = 0 ;
14719  int res1 = 0 ;
14720  PyObject * obj0 = 0 ;
14721  bool result;
14722 
14723  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttrib_optional_get",&obj0)) SWIG_fail;
14724  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
14725  if (!SWIG_IsOK(res1)) {
14726  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_optional_get" "', argument " "1"" of type '" "libbgp::BgpPathAttrib *""'");
14727  }
14728  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
14729  result = (bool) ((arg1)->optional);
14730  resultobj = SWIG_From_bool(static_cast< bool >(result));
14731  return resultobj;
14732 fail:
14733  return NULL;
14734 }
14735 
14736 
14737 SWIGINTERN PyObject *_wrap_BgpPathAttrib_transitive_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14738  PyObject *resultobj = 0;
14740  bool arg2 ;
14741  void *argp1 = 0 ;
14742  int res1 = 0 ;
14743  bool val2 ;
14744  int ecode2 = 0 ;
14745  PyObject * obj0 = 0 ;
14746  PyObject * obj1 = 0 ;
14747 
14748  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttrib_transitive_set",&obj0,&obj1)) SWIG_fail;
14749  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
14750  if (!SWIG_IsOK(res1)) {
14751  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_transitive_set" "', argument " "1"" of type '" "libbgp::BgpPathAttrib *""'");
14752  }
14753  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
14754  ecode2 = SWIG_AsVal_bool(obj1, &val2);
14755  if (!SWIG_IsOK(ecode2)) {
14756  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttrib_transitive_set" "', argument " "2"" of type '" "bool""'");
14757  }
14758  arg2 = static_cast< bool >(val2);
14759  if (arg1) (arg1)->transitive = arg2;
14760  resultobj = SWIG_Py_Void();
14761  return resultobj;
14762 fail:
14763  return NULL;
14764 }
14765 
14766 
14767 SWIGINTERN PyObject *_wrap_BgpPathAttrib_transitive_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14768  PyObject *resultobj = 0;
14770  void *argp1 = 0 ;
14771  int res1 = 0 ;
14772  PyObject * obj0 = 0 ;
14773  bool result;
14774 
14775  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttrib_transitive_get",&obj0)) SWIG_fail;
14776  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
14777  if (!SWIG_IsOK(res1)) {
14778  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_transitive_get" "', argument " "1"" of type '" "libbgp::BgpPathAttrib *""'");
14779  }
14780  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
14781  result = (bool) ((arg1)->transitive);
14782  resultobj = SWIG_From_bool(static_cast< bool >(result));
14783  return resultobj;
14784 fail:
14785  return NULL;
14786 }
14787 
14788 
14789 SWIGINTERN PyObject *_wrap_BgpPathAttrib_partial_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14790  PyObject *resultobj = 0;
14792  bool arg2 ;
14793  void *argp1 = 0 ;
14794  int res1 = 0 ;
14795  bool val2 ;
14796  int ecode2 = 0 ;
14797  PyObject * obj0 = 0 ;
14798  PyObject * obj1 = 0 ;
14799 
14800  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttrib_partial_set",&obj0,&obj1)) SWIG_fail;
14801  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
14802  if (!SWIG_IsOK(res1)) {
14803  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_partial_set" "', argument " "1"" of type '" "libbgp::BgpPathAttrib *""'");
14804  }
14805  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
14806  ecode2 = SWIG_AsVal_bool(obj1, &val2);
14807  if (!SWIG_IsOK(ecode2)) {
14808  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttrib_partial_set" "', argument " "2"" of type '" "bool""'");
14809  }
14810  arg2 = static_cast< bool >(val2);
14811  if (arg1) (arg1)->partial = arg2;
14812  resultobj = SWIG_Py_Void();
14813  return resultobj;
14814 fail:
14815  return NULL;
14816 }
14817 
14818 
14819 SWIGINTERN PyObject *_wrap_BgpPathAttrib_partial_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14820  PyObject *resultobj = 0;
14822  void *argp1 = 0 ;
14823  int res1 = 0 ;
14824  PyObject * obj0 = 0 ;
14825  bool result;
14826 
14827  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttrib_partial_get",&obj0)) SWIG_fail;
14828  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
14829  if (!SWIG_IsOK(res1)) {
14830  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_partial_get" "', argument " "1"" of type '" "libbgp::BgpPathAttrib *""'");
14831  }
14832  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
14833  result = (bool) ((arg1)->partial);
14834  resultobj = SWIG_From_bool(static_cast< bool >(result));
14835  return resultobj;
14836 fail:
14837  return NULL;
14838 }
14839 
14840 
14841 SWIGINTERN PyObject *_wrap_BgpPathAttrib_extended_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14842  PyObject *resultobj = 0;
14844  bool arg2 ;
14845  void *argp1 = 0 ;
14846  int res1 = 0 ;
14847  bool val2 ;
14848  int ecode2 = 0 ;
14849  PyObject * obj0 = 0 ;
14850  PyObject * obj1 = 0 ;
14851 
14852  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttrib_extended_set",&obj0,&obj1)) SWIG_fail;
14853  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
14854  if (!SWIG_IsOK(res1)) {
14855  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_extended_set" "', argument " "1"" of type '" "libbgp::BgpPathAttrib *""'");
14856  }
14857  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
14858  ecode2 = SWIG_AsVal_bool(obj1, &val2);
14859  if (!SWIG_IsOK(ecode2)) {
14860  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttrib_extended_set" "', argument " "2"" of type '" "bool""'");
14861  }
14862  arg2 = static_cast< bool >(val2);
14863  if (arg1) (arg1)->extended = arg2;
14864  resultobj = SWIG_Py_Void();
14865  return resultobj;
14866 fail:
14867  return NULL;
14868 }
14869 
14870 
14871 SWIGINTERN PyObject *_wrap_BgpPathAttrib_extended_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14872  PyObject *resultobj = 0;
14874  void *argp1 = 0 ;
14875  int res1 = 0 ;
14876  PyObject * obj0 = 0 ;
14877  bool result;
14878 
14879  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttrib_extended_get",&obj0)) SWIG_fail;
14880  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
14881  if (!SWIG_IsOK(res1)) {
14882  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_extended_get" "', argument " "1"" of type '" "libbgp::BgpPathAttrib *""'");
14883  }
14884  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
14885  result = (bool) ((arg1)->extended);
14886  resultobj = SWIG_From_bool(static_cast< bool >(result));
14887  return resultobj;
14888 fail:
14889  return NULL;
14890 }
14891 
14892 
14893 SWIGINTERN PyObject *_wrap_BgpPathAttrib_type_code_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14894  PyObject *resultobj = 0;
14896  uint8_t arg2 ;
14897  void *argp1 = 0 ;
14898  int res1 = 0 ;
14899  unsigned char val2 ;
14900  int ecode2 = 0 ;
14901  PyObject * obj0 = 0 ;
14902  PyObject * obj1 = 0 ;
14903 
14904  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttrib_type_code_set",&obj0,&obj1)) SWIG_fail;
14905  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
14906  if (!SWIG_IsOK(res1)) {
14907  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_type_code_set" "', argument " "1"" of type '" "libbgp::BgpPathAttrib *""'");
14908  }
14909  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
14910  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14911  if (!SWIG_IsOK(ecode2)) {
14912  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttrib_type_code_set" "', argument " "2"" of type '" "uint8_t""'");
14913  }
14914  arg2 = static_cast< uint8_t >(val2);
14915  if (arg1) (arg1)->type_code = arg2;
14916  resultobj = SWIG_Py_Void();
14917  return resultobj;
14918 fail:
14919  return NULL;
14920 }
14921 
14922 
14923 SWIGINTERN PyObject *_wrap_BgpPathAttrib_type_code_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14924  PyObject *resultobj = 0;
14926  void *argp1 = 0 ;
14927  int res1 = 0 ;
14928  PyObject * obj0 = 0 ;
14929  uint8_t result;
14930 
14931  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttrib_type_code_get",&obj0)) SWIG_fail;
14932  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
14933  if (!SWIG_IsOK(res1)) {
14934  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_type_code_get" "', argument " "1"" of type '" "libbgp::BgpPathAttrib *""'");
14935  }
14936  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
14937  result = (uint8_t) ((arg1)->type_code);
14938  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14939  return resultobj;
14940 fail:
14941  return NULL;
14942 }
14943 
14944 
14945 SWIGINTERN PyObject *_wrap_new_BgpPathAttrib__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14946  PyObject *resultobj = 0;
14948  void *argp1 = 0 ;
14949  int res1 = 0 ;
14950  PyObject * obj0 = 0 ;
14951  libbgp::BgpPathAttrib *result = 0 ;
14952 
14953  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpPathAttrib",&obj0)) SWIG_fail;
14954  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
14955  if (!SWIG_IsOK(res1)) {
14956  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttrib" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
14957  }
14958  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
14959  result = (libbgp::BgpPathAttrib *)new libbgp::BgpPathAttrib(arg1);
14960  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, SWIG_POINTER_NEW | 0 );
14961  return resultobj;
14962 fail:
14963  return NULL;
14964 }
14965 
14966 
14967 SWIGINTERN PyObject *_wrap_new_BgpPathAttrib__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14968  PyObject *resultobj = 0;
14970  uint8_t *arg2 = (uint8_t *) 0 ;
14971  uint16_t arg3 ;
14972  void *argp1 = 0 ;
14973  int res1 = 0 ;
14974  void *argp2 = 0 ;
14975  int res2 = 0 ;
14976  unsigned short val3 ;
14977  int ecode3 = 0 ;
14978  PyObject * obj0 = 0 ;
14979  PyObject * obj1 = 0 ;
14980  PyObject * obj2 = 0 ;
14981  libbgp::BgpPathAttrib *result = 0 ;
14982 
14983  if (!PyArg_ParseTuple(args,(char *)"OOO:new_BgpPathAttrib",&obj0,&obj1,&obj2)) SWIG_fail;
14984  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
14985  if (!SWIG_IsOK(res1)) {
14986  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttrib" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
14987  }
14988  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
14989  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
14990  if (!SWIG_IsOK(res2)) {
14991  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BgpPathAttrib" "', argument " "2"" of type '" "uint8_t const *""'");
14992  }
14993  arg2 = reinterpret_cast< uint8_t * >(argp2);
14994  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
14995  if (!SWIG_IsOK(ecode3)) {
14996  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BgpPathAttrib" "', argument " "3"" of type '" "uint16_t""'");
14997  }
14998  arg3 = static_cast< uint16_t >(val3);
14999  result = (libbgp::BgpPathAttrib *)new libbgp::BgpPathAttrib(arg1,(uint8_t const *)arg2,arg3);
15000  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, SWIG_POINTER_NEW | 0 );
15001  return resultobj;
15002 fail:
15003  return NULL;
15004 }
15005 
15006 
15007 SWIGINTERN PyObject *_wrap_new_BgpPathAttrib(PyObject *self, PyObject *args) {
15008  Py_ssize_t argc;
15009  PyObject *argv[4] = {
15010  0
15011  };
15012  Py_ssize_t ii;
15013 
15014  if (!PyTuple_Check(args)) SWIG_fail;
15015  argc = args ? PyObject_Length(args) : 0;
15016  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
15017  argv[ii] = PyTuple_GET_ITEM(args,ii);
15018  }
15019  if (argc == 1) {
15020  int _v;
15021  void *vptr = 0;
15022  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
15023  _v = SWIG_CheckState(res);
15024  if (_v) {
15025  return _wrap_new_BgpPathAttrib__SWIG_0(self, args);
15026  }
15027  }
15028  if (argc == 3) {
15029  int _v;
15030  void *vptr = 0;
15031  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
15032  _v = SWIG_CheckState(res);
15033  if (_v) {
15034  void *vptr = 0;
15035  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
15036  _v = SWIG_CheckState(res);
15037  if (_v) {
15038  {
15039  int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
15040  _v = SWIG_CheckState(res);
15041  }
15042  if (_v) {
15043  return _wrap_new_BgpPathAttrib__SWIG_1(self, args);
15044  }
15045  }
15046  }
15047  }
15048 
15049 fail:
15050  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BgpPathAttrib'.\n"
15051  " Possible C/C++ prototypes are:\n"
15052  " libbgp::BgpPathAttrib::BgpPathAttrib(libbgp::BgpLogHandler *)\n"
15053  " libbgp::BgpPathAttrib::BgpPathAttrib(libbgp::BgpLogHandler *,uint8_t const *,uint16_t)\n");
15054  return 0;
15055 }
15056 
15057 
15058 SWIGINTERN PyObject *_wrap_BgpPathAttrib_GetTypeFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15059  PyObject *resultobj = 0;
15060  uint8_t *arg1 = (uint8_t *) 0 ;
15061  size_t arg2 ;
15062  void *argp1 = 0 ;
15063  int res1 = 0 ;
15064  size_t val2 ;
15065  int ecode2 = 0 ;
15066  PyObject * obj0 = 0 ;
15067  PyObject * obj1 = 0 ;
15068  uint8_t result;
15069 
15070  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttrib_GetTypeFromBuffer",&obj0,&obj1)) SWIG_fail;
15071  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 | 0 );
15072  if (!SWIG_IsOK(res1)) {
15073  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_GetTypeFromBuffer" "', argument " "1"" of type '" "uint8_t const *""'");
15074  }
15075  arg1 = reinterpret_cast< uint8_t * >(argp1);
15076  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15077  if (!SWIG_IsOK(ecode2)) {
15078  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttrib_GetTypeFromBuffer" "', argument " "2"" of type '" "size_t""'");
15079  }
15080  arg2 = static_cast< size_t >(val2);
15081  result = (uint8_t)libbgp::BgpPathAttrib::GetTypeFromBuffer((unsigned char const *)arg1,arg2);
15082  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15083  return resultobj;
15084 fail:
15085  return NULL;
15086 }
15087 
15088 
15089 SWIGINTERN PyObject *_wrap_BgpPathAttrib_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15090  PyObject *resultobj = 0;
15092  size_t arg2 ;
15093  uint8_t **arg3 = (uint8_t **) 0 ;
15094  size_t *arg4 = (size_t *) 0 ;
15095  void *argp1 = 0 ;
15096  int res1 = 0 ;
15097  size_t val2 ;
15098  int ecode2 = 0 ;
15099  void *argp3 = 0 ;
15100  int res3 = 0 ;
15101  void *argp4 = 0 ;
15102  int res4 = 0 ;
15103  PyObject * obj0 = 0 ;
15104  PyObject * obj1 = 0 ;
15105  PyObject * obj2 = 0 ;
15106  PyObject * obj3 = 0 ;
15107  ssize_t result;
15108 
15109  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttrib_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15110  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
15111  if (!SWIG_IsOK(res1)) {
15112  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttrib const *""'");
15113  }
15114  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
15115  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15116  if (!SWIG_IsOK(ecode2)) {
15117  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttrib_doPrint" "', argument " "2"" of type '" "size_t""'");
15118  }
15119  arg2 = static_cast< size_t >(val2);
15120  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
15121  if (!SWIG_IsOK(res3)) {
15122  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttrib_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
15123  }
15124  arg3 = reinterpret_cast< uint8_t ** >(argp3);
15125  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
15126  if (!SWIG_IsOK(res4)) {
15127  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttrib_doPrint" "', argument " "4"" of type '" "size_t *""'");
15128  }
15129  arg4 = reinterpret_cast< size_t * >(argp4);
15130  result = ((libbgp::BgpPathAttrib const *)arg1)->doPrint(arg2,arg3,arg4);
15131  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
15132  return resultobj;
15133 fail:
15134  return NULL;
15135 }
15136 
15137 
15138 SWIGINTERN PyObject *_wrap_BgpPathAttrib_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15139  PyObject *resultobj = 0;
15141  uint8_t *arg2 = (uint8_t *) 0 ;
15142  size_t arg3 ;
15143  void *argp1 = 0 ;
15144  int res1 = 0 ;
15145  void *argp2 = 0 ;
15146  int res2 = 0 ;
15147  size_t val3 ;
15148  int ecode3 = 0 ;
15149  PyObject * obj0 = 0 ;
15150  PyObject * obj1 = 0 ;
15151  PyObject * obj2 = 0 ;
15152  ssize_t result;
15153 
15154  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttrib_parse",&obj0,&obj1,&obj2)) SWIG_fail;
15155  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
15156  if (!SWIG_IsOK(res1)) {
15157  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttrib *""'");
15158  }
15159  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
15160  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
15161  if (!SWIG_IsOK(res2)) {
15162  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttrib_parse" "', argument " "2"" of type '" "uint8_t const *""'");
15163  }
15164  arg2 = reinterpret_cast< uint8_t * >(argp2);
15165  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
15166  if (!SWIG_IsOK(ecode3)) {
15167  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttrib_parse" "', argument " "3"" of type '" "size_t""'");
15168  }
15169  arg3 = static_cast< size_t >(val3);
15170  result = (arg1)->parse((uint8_t const *)arg2,arg3);
15171  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
15172  return resultobj;
15173 fail:
15174  return NULL;
15175 }
15176 
15177 
15178 SWIGINTERN PyObject *_wrap_BgpPathAttrib_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15179  PyObject *resultobj = 0;
15181  uint8_t *arg2 = (uint8_t *) 0 ;
15182  size_t arg3 ;
15183  void *argp1 = 0 ;
15184  int res1 = 0 ;
15185  void *argp2 = 0 ;
15186  int res2 = 0 ;
15187  size_t val3 ;
15188  int ecode3 = 0 ;
15189  PyObject * obj0 = 0 ;
15190  PyObject * obj1 = 0 ;
15191  PyObject * obj2 = 0 ;
15192  ssize_t result;
15193 
15194  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttrib_write",&obj0,&obj1,&obj2)) SWIG_fail;
15195  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
15196  if (!SWIG_IsOK(res1)) {
15197  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_write" "', argument " "1"" of type '" "libbgp::BgpPathAttrib const *""'");
15198  }
15199  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
15200  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
15201  if (!SWIG_IsOK(res2)) {
15202  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttrib_write" "', argument " "2"" of type '" "uint8_t *""'");
15203  }
15204  arg2 = reinterpret_cast< uint8_t * >(argp2);
15205  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
15206  if (!SWIG_IsOK(ecode3)) {
15207  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttrib_write" "', argument " "3"" of type '" "size_t""'");
15208  }
15209  arg3 = static_cast< size_t >(val3);
15210  result = ((libbgp::BgpPathAttrib const *)arg1)->write(arg2,arg3);
15211  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
15212  return resultobj;
15213 fail:
15214  return NULL;
15215 }
15216 
15217 
15218 SWIGINTERN PyObject *_wrap_BgpPathAttrib_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15219  PyObject *resultobj = 0;
15221  void *argp1 = 0 ;
15222  int res1 = 0 ;
15223  PyObject * obj0 = 0 ;
15224  ssize_t result;
15225 
15226  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttrib_length",&obj0)) SWIG_fail;
15227  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
15228  if (!SWIG_IsOK(res1)) {
15229  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_length" "', argument " "1"" of type '" "libbgp::BgpPathAttrib const *""'");
15230  }
15231  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
15232  result = ((libbgp::BgpPathAttrib const *)arg1)->length();
15233  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
15234  return resultobj;
15235 fail:
15236  return NULL;
15237 }
15238 
15239 
15240 SWIGINTERN PyObject *_wrap_BgpPathAttrib_clone__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15241  PyObject *resultobj = 0;
15244  void *argp1 = 0 ;
15245  int res1 = 0 ;
15246  void *argp2 = 0 ;
15247  int res2 = 0 ;
15248  PyObject * obj0 = 0 ;
15249  PyObject * obj1 = 0 ;
15250  libbgp::BgpPathAttrib *result = 0 ;
15251 
15252  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttrib_clone",&obj0,&obj1)) SWIG_fail;
15253  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
15254  if (!SWIG_IsOK(res1)) {
15255  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttrib const *""'");
15256  }
15257  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
15258  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
15259  if (!SWIG_IsOK(res2)) {
15260  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttrib_clone" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
15261  }
15262  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
15263  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttrib const *)arg1)->clone(arg2);
15264  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
15265  return resultobj;
15266 fail:
15267  return NULL;
15268 }
15269 
15270 
15271 SWIGINTERN PyObject *_wrap_BgpPathAttrib_clone__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15272  PyObject *resultobj = 0;
15274  void *argp1 = 0 ;
15275  int res1 = 0 ;
15276  PyObject * obj0 = 0 ;
15277  libbgp::BgpPathAttrib *result = 0 ;
15278 
15279  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttrib_clone",&obj0)) SWIG_fail;
15280  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
15281  if (!SWIG_IsOK(res1)) {
15282  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttrib_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttrib const *""'");
15283  }
15284  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
15285  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttrib const *)arg1)->clone();
15286  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
15287  return resultobj;
15288 fail:
15289  return NULL;
15290 }
15291 
15292 
15293 SWIGINTERN PyObject *_wrap_BgpPathAttrib_clone(PyObject *self, PyObject *args) {
15294  Py_ssize_t argc;
15295  PyObject *argv[3] = {
15296  0
15297  };
15298  Py_ssize_t ii;
15299 
15300  if (!PyTuple_Check(args)) SWIG_fail;
15301  argc = args ? PyObject_Length(args) : 0;
15302  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
15303  argv[ii] = PyTuple_GET_ITEM(args,ii);
15304  }
15305  if (argc == 1) {
15306  int _v;
15307  void *vptr = 0;
15308  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpPathAttrib, 0);
15309  _v = SWIG_CheckState(res);
15310  if (_v) {
15311  return _wrap_BgpPathAttrib_clone__SWIG_1(self, args);
15312  }
15313  }
15314  if (argc == 2) {
15315  int _v;
15316  void *vptr = 0;
15317  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpPathAttrib, 0);
15318  _v = SWIG_CheckState(res);
15319  if (_v) {
15320  void *vptr = 0;
15321  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
15322  _v = SWIG_CheckState(res);
15323  if (_v) {
15324  return _wrap_BgpPathAttrib_clone__SWIG_0(self, args);
15325  }
15326  }
15327  }
15328 
15329 fail:
15330  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BgpPathAttrib_clone'.\n"
15331  " Possible C/C++ prototypes are:\n"
15332  " libbgp::BgpPathAttrib::clone(libbgp::BgpLogHandler *) const\n"
15333  " libbgp::BgpPathAttrib::clone() const\n");
15334  return 0;
15335 }
15336 
15337 
15338 SWIGINTERN PyObject *_wrap_delete_BgpPathAttrib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15339  PyObject *resultobj = 0;
15341  void *argp1 = 0 ;
15342  int res1 = 0 ;
15343  PyObject * obj0 = 0 ;
15344 
15345  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttrib",&obj0)) SWIG_fail;
15346  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttrib, SWIG_POINTER_DISOWN | 0 );
15347  if (!SWIG_IsOK(res1)) {
15348  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttrib" "', argument " "1"" of type '" "libbgp::BgpPathAttrib *""'");
15349  }
15350  arg1 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp1);
15351  delete arg1;
15352  resultobj = SWIG_Py_Void();
15353  return resultobj;
15354 fail:
15355  return NULL;
15356 }
15357 
15358 
15359 SWIGINTERN PyObject *BgpPathAttrib_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15360  PyObject *obj;
15361  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
15362  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttrib, SWIG_NewClientData(obj));
15363  return SWIG_Py_Void();
15364 }
15365 
15366 SWIGINTERN PyObject *_wrap_new_BgpPathAttribOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15367  PyObject *resultobj = 0;
15369  void *argp1 = 0 ;
15370  int res1 = 0 ;
15371  PyObject * obj0 = 0 ;
15372  libbgp::BgpPathAttribOrigin *result = 0 ;
15373 
15374  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpPathAttribOrigin",&obj0)) SWIG_fail;
15375  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
15376  if (!SWIG_IsOK(res1)) {
15377  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribOrigin" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
15378  }
15379  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
15381  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribOrigin, SWIG_POINTER_NEW | 0 );
15382  return resultobj;
15383 fail:
15384  return NULL;
15385 }
15386 
15387 
15388 SWIGINTERN PyObject *_wrap_BgpPathAttribOrigin_origin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15389  PyObject *resultobj = 0;
15391  uint8_t arg2 ;
15392  void *argp1 = 0 ;
15393  int res1 = 0 ;
15394  unsigned char val2 ;
15395  int ecode2 = 0 ;
15396  PyObject * obj0 = 0 ;
15397  PyObject * obj1 = 0 ;
15398 
15399  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribOrigin_origin_set",&obj0,&obj1)) SWIG_fail;
15400  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribOrigin, 0 | 0 );
15401  if (!SWIG_IsOK(res1)) {
15402  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribOrigin_origin_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribOrigin *""'");
15403  }
15404  arg1 = reinterpret_cast< libbgp::BgpPathAttribOrigin * >(argp1);
15405  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15406  if (!SWIG_IsOK(ecode2)) {
15407  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribOrigin_origin_set" "', argument " "2"" of type '" "uint8_t""'");
15408  }
15409  arg2 = static_cast< uint8_t >(val2);
15410  if (arg1) (arg1)->origin = arg2;
15411  resultobj = SWIG_Py_Void();
15412  return resultobj;
15413 fail:
15414  return NULL;
15415 }
15416 
15417 
15418 SWIGINTERN PyObject *_wrap_BgpPathAttribOrigin_origin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15419  PyObject *resultobj = 0;
15421  void *argp1 = 0 ;
15422  int res1 = 0 ;
15423  PyObject * obj0 = 0 ;
15424  uint8_t result;
15425 
15426  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribOrigin_origin_get",&obj0)) SWIG_fail;
15427  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribOrigin, 0 | 0 );
15428  if (!SWIG_IsOK(res1)) {
15429  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribOrigin_origin_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribOrigin *""'");
15430  }
15431  arg1 = reinterpret_cast< libbgp::BgpPathAttribOrigin * >(argp1);
15432  result = (uint8_t) ((arg1)->origin);
15433  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15434  return resultobj;
15435 fail:
15436  return NULL;
15437 }
15438 
15439 
15440 SWIGINTERN PyObject *_wrap_BgpPathAttribOrigin_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15441  PyObject *resultobj = 0;
15443  void *argp1 = 0 ;
15444  int res1 = 0 ;
15445  PyObject * obj0 = 0 ;
15446  libbgp::BgpPathAttrib *result = 0 ;
15447 
15448  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribOrigin_clone",&obj0)) SWIG_fail;
15449  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribOrigin, 0 | 0 );
15450  if (!SWIG_IsOK(res1)) {
15451  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribOrigin_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttribOrigin const *""'");
15452  }
15453  arg1 = reinterpret_cast< libbgp::BgpPathAttribOrigin * >(argp1);
15454  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttribOrigin const *)arg1)->clone();
15455  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
15456  return resultobj;
15457 fail:
15458  return NULL;
15459 }
15460 
15461 
15462 SWIGINTERN PyObject *_wrap_BgpPathAttribOrigin_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15463  PyObject *resultobj = 0;
15465  uint8_t *arg2 = (uint8_t *) 0 ;
15466  size_t arg3 ;
15467  void *argp1 = 0 ;
15468  int res1 = 0 ;
15469  void *argp2 = 0 ;
15470  int res2 = 0 ;
15471  size_t val3 ;
15472  int ecode3 = 0 ;
15473  PyObject * obj0 = 0 ;
15474  PyObject * obj1 = 0 ;
15475  PyObject * obj2 = 0 ;
15476  ssize_t result;
15477 
15478  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribOrigin_parse",&obj0,&obj1,&obj2)) SWIG_fail;
15479  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribOrigin, 0 | 0 );
15480  if (!SWIG_IsOK(res1)) {
15481  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribOrigin_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttribOrigin *""'");
15482  }
15483  arg1 = reinterpret_cast< libbgp::BgpPathAttribOrigin * >(argp1);
15484  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
15485  if (!SWIG_IsOK(res2)) {
15486  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribOrigin_parse" "', argument " "2"" of type '" "uint8_t const *""'");
15487  }
15488  arg2 = reinterpret_cast< uint8_t * >(argp2);
15489  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
15490  if (!SWIG_IsOK(ecode3)) {
15491  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribOrigin_parse" "', argument " "3"" of type '" "size_t""'");
15492  }
15493  arg3 = static_cast< size_t >(val3);
15494  result = (arg1)->parse((uint8_t const *)arg2,arg3);
15495  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
15496  return resultobj;
15497 fail:
15498  return NULL;
15499 }
15500 
15501 
15502 SWIGINTERN PyObject *_wrap_BgpPathAttribOrigin_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15503  PyObject *resultobj = 0;
15505  uint8_t *arg2 = (uint8_t *) 0 ;
15506  size_t arg3 ;
15507  void *argp1 = 0 ;
15508  int res1 = 0 ;
15509  void *argp2 = 0 ;
15510  int res2 = 0 ;
15511  size_t val3 ;
15512  int ecode3 = 0 ;
15513  PyObject * obj0 = 0 ;
15514  PyObject * obj1 = 0 ;
15515  PyObject * obj2 = 0 ;
15516  ssize_t result;
15517 
15518  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribOrigin_write",&obj0,&obj1,&obj2)) SWIG_fail;
15519  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribOrigin, 0 | 0 );
15520  if (!SWIG_IsOK(res1)) {
15521  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribOrigin_write" "', argument " "1"" of type '" "libbgp::BgpPathAttribOrigin const *""'");
15522  }
15523  arg1 = reinterpret_cast< libbgp::BgpPathAttribOrigin * >(argp1);
15524  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
15525  if (!SWIG_IsOK(res2)) {
15526  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribOrigin_write" "', argument " "2"" of type '" "uint8_t *""'");
15527  }
15528  arg2 = reinterpret_cast< uint8_t * >(argp2);
15529  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
15530  if (!SWIG_IsOK(ecode3)) {
15531  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribOrigin_write" "', argument " "3"" of type '" "size_t""'");
15532  }
15533  arg3 = static_cast< size_t >(val3);
15534  result = ((libbgp::BgpPathAttribOrigin const *)arg1)->write(arg2,arg3);
15535  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
15536  return resultobj;
15537 fail:
15538  return NULL;
15539 }
15540 
15541 
15542 SWIGINTERN PyObject *_wrap_BgpPathAttribOrigin_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15543  PyObject *resultobj = 0;
15545  size_t arg2 ;
15546  uint8_t **arg3 = (uint8_t **) 0 ;
15547  size_t *arg4 = (size_t *) 0 ;
15548  void *argp1 = 0 ;
15549  int res1 = 0 ;
15550  size_t val2 ;
15551  int ecode2 = 0 ;
15552  void *argp3 = 0 ;
15553  int res3 = 0 ;
15554  void *argp4 = 0 ;
15555  int res4 = 0 ;
15556  PyObject * obj0 = 0 ;
15557  PyObject * obj1 = 0 ;
15558  PyObject * obj2 = 0 ;
15559  PyObject * obj3 = 0 ;
15560  ssize_t result;
15561 
15562  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttribOrigin_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15563  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribOrigin, 0 | 0 );
15564  if (!SWIG_IsOK(res1)) {
15565  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribOrigin_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttribOrigin const *""'");
15566  }
15567  arg1 = reinterpret_cast< libbgp::BgpPathAttribOrigin * >(argp1);
15568  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
15569  if (!SWIG_IsOK(ecode2)) {
15570  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribOrigin_doPrint" "', argument " "2"" of type '" "size_t""'");
15571  }
15572  arg2 = static_cast< size_t >(val2);
15573  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
15574  if (!SWIG_IsOK(res3)) {
15575  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttribOrigin_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
15576  }
15577  arg3 = reinterpret_cast< uint8_t ** >(argp3);
15578  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
15579  if (!SWIG_IsOK(res4)) {
15580  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttribOrigin_doPrint" "', argument " "4"" of type '" "size_t *""'");
15581  }
15582  arg4 = reinterpret_cast< size_t * >(argp4);
15583  result = ((libbgp::BgpPathAttribOrigin const *)arg1)->doPrint(arg2,arg3,arg4);
15584  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
15585  return resultobj;
15586 fail:
15587  return NULL;
15588 }
15589 
15590 
15591 SWIGINTERN PyObject *_wrap_BgpPathAttribOrigin_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15592  PyObject *resultobj = 0;
15594  void *argp1 = 0 ;
15595  int res1 = 0 ;
15596  PyObject * obj0 = 0 ;
15597  ssize_t result;
15598 
15599  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribOrigin_length",&obj0)) SWIG_fail;
15600  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribOrigin, 0 | 0 );
15601  if (!SWIG_IsOK(res1)) {
15602  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribOrigin_length" "', argument " "1"" of type '" "libbgp::BgpPathAttribOrigin const *""'");
15603  }
15604  arg1 = reinterpret_cast< libbgp::BgpPathAttribOrigin * >(argp1);
15605  result = ((libbgp::BgpPathAttribOrigin const *)arg1)->length();
15606  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
15607  return resultobj;
15608 fail:
15609  return NULL;
15610 }
15611 
15612 
15613 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15614  PyObject *resultobj = 0;
15616  void *argp1 = 0 ;
15617  int res1 = 0 ;
15618  PyObject * obj0 = 0 ;
15619 
15620  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribOrigin",&obj0)) SWIG_fail;
15621  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribOrigin, SWIG_POINTER_DISOWN | 0 );
15622  if (!SWIG_IsOK(res1)) {
15623  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribOrigin" "', argument " "1"" of type '" "libbgp::BgpPathAttribOrigin *""'");
15624  }
15625  arg1 = reinterpret_cast< libbgp::BgpPathAttribOrigin * >(argp1);
15626  delete arg1;
15627  resultobj = SWIG_Py_Void();
15628  return resultobj;
15629 fail:
15630  return NULL;
15631 }
15632 
15633 
15634 SWIGINTERN PyObject *BgpPathAttribOrigin_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15635  PyObject *obj;
15636  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
15637  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribOrigin, SWIG_NewClientData(obj));
15638  return SWIG_Py_Void();
15639 }
15640 
15641 SWIGINTERN PyObject *_wrap_new_BgpAsPathSegment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15642  PyObject *resultobj = 0;
15643  bool arg1 ;
15644  uint8_t arg2 ;
15645  bool val1 ;
15646  int ecode1 = 0 ;
15647  unsigned char val2 ;
15648  int ecode2 = 0 ;
15649  PyObject * obj0 = 0 ;
15650  PyObject * obj1 = 0 ;
15651  libbgp::BgpAsPathSegment *result = 0 ;
15652 
15653  if (!PyArg_ParseTuple(args,(char *)"OO:new_BgpAsPathSegment",&obj0,&obj1)) SWIG_fail;
15654  ecode1 = SWIG_AsVal_bool(obj0, &val1);
15655  if (!SWIG_IsOK(ecode1)) {
15656  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BgpAsPathSegment" "', argument " "1"" of type '" "bool""'");
15657  }
15658  arg1 = static_cast< bool >(val1);
15659  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15660  if (!SWIG_IsOK(ecode2)) {
15661  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpAsPathSegment" "', argument " "2"" of type '" "uint8_t""'");
15662  }
15663  arg2 = static_cast< uint8_t >(val2);
15664  result = (libbgp::BgpAsPathSegment *)new libbgp::BgpAsPathSegment(arg1,arg2);
15665  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpAsPathSegment, SWIG_POINTER_NEW | 0 );
15666  return resultobj;
15667 fail:
15668  return NULL;
15669 }
15670 
15671 
15672 SWIGINTERN PyObject *_wrap_BgpAsPathSegment_is_4b_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15673  PyObject *resultobj = 0;
15675  bool arg2 ;
15676  void *argp1 = 0 ;
15677  int res1 = 0 ;
15678  bool val2 ;
15679  int ecode2 = 0 ;
15680  PyObject * obj0 = 0 ;
15681  PyObject * obj1 = 0 ;
15682 
15683  if (!PyArg_ParseTuple(args,(char *)"OO:BgpAsPathSegment_is_4b_set",&obj0,&obj1)) SWIG_fail;
15684  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpAsPathSegment, 0 | 0 );
15685  if (!SWIG_IsOK(res1)) {
15686  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpAsPathSegment_is_4b_set" "', argument " "1"" of type '" "libbgp::BgpAsPathSegment *""'");
15687  }
15688  arg1 = reinterpret_cast< libbgp::BgpAsPathSegment * >(argp1);
15689  ecode2 = SWIG_AsVal_bool(obj1, &val2);
15690  if (!SWIG_IsOK(ecode2)) {
15691  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpAsPathSegment_is_4b_set" "', argument " "2"" of type '" "bool""'");
15692  }
15693  arg2 = static_cast< bool >(val2);
15694  if (arg1) (arg1)->is_4b = arg2;
15695  resultobj = SWIG_Py_Void();
15696  return resultobj;
15697 fail:
15698  return NULL;
15699 }
15700 
15701 
15702 SWIGINTERN PyObject *_wrap_BgpAsPathSegment_is_4b_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15703  PyObject *resultobj = 0;
15705  void *argp1 = 0 ;
15706  int res1 = 0 ;
15707  PyObject * obj0 = 0 ;
15708  bool result;
15709 
15710  if (!PyArg_ParseTuple(args,(char *)"O:BgpAsPathSegment_is_4b_get",&obj0)) SWIG_fail;
15711  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpAsPathSegment, 0 | 0 );
15712  if (!SWIG_IsOK(res1)) {
15713  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpAsPathSegment_is_4b_get" "', argument " "1"" of type '" "libbgp::BgpAsPathSegment *""'");
15714  }
15715  arg1 = reinterpret_cast< libbgp::BgpAsPathSegment * >(argp1);
15716  result = (bool) ((arg1)->is_4b);
15717  resultobj = SWIG_From_bool(static_cast< bool >(result));
15718  return resultobj;
15719 fail:
15720  return NULL;
15721 }
15722 
15723 
15724 SWIGINTERN PyObject *_wrap_BgpAsPathSegment_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15725  PyObject *resultobj = 0;
15727  uint8_t arg2 ;
15728  void *argp1 = 0 ;
15729  int res1 = 0 ;
15730  unsigned char val2 ;
15731  int ecode2 = 0 ;
15732  PyObject * obj0 = 0 ;
15733  PyObject * obj1 = 0 ;
15734 
15735  if (!PyArg_ParseTuple(args,(char *)"OO:BgpAsPathSegment_type_set",&obj0,&obj1)) SWIG_fail;
15736  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpAsPathSegment, 0 | 0 );
15737  if (!SWIG_IsOK(res1)) {
15738  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpAsPathSegment_type_set" "', argument " "1"" of type '" "libbgp::BgpAsPathSegment *""'");
15739  }
15740  arg1 = reinterpret_cast< libbgp::BgpAsPathSegment * >(argp1);
15741  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15742  if (!SWIG_IsOK(ecode2)) {
15743  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpAsPathSegment_type_set" "', argument " "2"" of type '" "uint8_t""'");
15744  }
15745  arg2 = static_cast< uint8_t >(val2);
15746  if (arg1) (arg1)->type = arg2;
15747  resultobj = SWIG_Py_Void();
15748  return resultobj;
15749 fail:
15750  return NULL;
15751 }
15752 
15753 
15754 SWIGINTERN PyObject *_wrap_BgpAsPathSegment_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15755  PyObject *resultobj = 0;
15757  void *argp1 = 0 ;
15758  int res1 = 0 ;
15759  PyObject * obj0 = 0 ;
15760  uint8_t result;
15761 
15762  if (!PyArg_ParseTuple(args,(char *)"O:BgpAsPathSegment_type_get",&obj0)) SWIG_fail;
15763  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpAsPathSegment, 0 | 0 );
15764  if (!SWIG_IsOK(res1)) {
15765  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpAsPathSegment_type_get" "', argument " "1"" of type '" "libbgp::BgpAsPathSegment *""'");
15766  }
15767  arg1 = reinterpret_cast< libbgp::BgpAsPathSegment * >(argp1);
15768  result = (uint8_t) ((arg1)->type);
15769  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15770  return resultobj;
15771 fail:
15772  return NULL;
15773 }
15774 
15775 
15776 SWIGINTERN PyObject *_wrap_BgpAsPathSegment_getCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15777  PyObject *resultobj = 0;
15779  void *argp1 = 0 ;
15780  int res1 = 0 ;
15781  PyObject * obj0 = 0 ;
15782  size_t result;
15783 
15784  if (!PyArg_ParseTuple(args,(char *)"O:BgpAsPathSegment_getCount",&obj0)) SWIG_fail;
15785  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpAsPathSegment, 0 | 0 );
15786  if (!SWIG_IsOK(res1)) {
15787  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpAsPathSegment_getCount" "', argument " "1"" of type '" "libbgp::BgpAsPathSegment const *""'");
15788  }
15789  arg1 = reinterpret_cast< libbgp::BgpAsPathSegment * >(argp1);
15790  result = ((libbgp::BgpAsPathSegment const *)arg1)->getCount();
15791  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
15792  return resultobj;
15793 fail:
15794  return NULL;
15795 }
15796 
15797 
15798 SWIGINTERN PyObject *_wrap_BgpAsPathSegment_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15799  PyObject *resultobj = 0;
15801  uint32_t arg2 ;
15802  void *argp1 = 0 ;
15803  int res1 = 0 ;
15804  unsigned int val2 ;
15805  int ecode2 = 0 ;
15806  PyObject * obj0 = 0 ;
15807  PyObject * obj1 = 0 ;
15808  bool result;
15809 
15810  if (!PyArg_ParseTuple(args,(char *)"OO:BgpAsPathSegment_prepend",&obj0,&obj1)) SWIG_fail;
15811  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpAsPathSegment, 0 | 0 );
15812  if (!SWIG_IsOK(res1)) {
15813  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpAsPathSegment_prepend" "', argument " "1"" of type '" "libbgp::BgpAsPathSegment *""'");
15814  }
15815  arg1 = reinterpret_cast< libbgp::BgpAsPathSegment * >(argp1);
15816  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
15817  if (!SWIG_IsOK(ecode2)) {
15818  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpAsPathSegment_prepend" "', argument " "2"" of type '" "uint32_t""'");
15819  }
15820  arg2 = static_cast< uint32_t >(val2);
15821  result = (bool)(arg1)->prepend(arg2);
15822  resultobj = SWIG_From_bool(static_cast< bool >(result));
15823  return resultobj;
15824 fail:
15825  return NULL;
15826 }
15827 
15828 
15829 SWIGINTERN PyObject *_wrap_BgpAsPathSegment_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15830  PyObject *resultobj = 0;
15832  std::vector< uint32_t > arg2 ;
15833  void *argp1 = 0 ;
15834  int res1 = 0 ;
15835  void *argp2 ;
15836  int res2 = 0 ;
15837  PyObject * obj0 = 0 ;
15838  PyObject * obj1 = 0 ;
15839 
15840  if (!PyArg_ParseTuple(args,(char *)"OO:BgpAsPathSegment_value_set",&obj0,&obj1)) SWIG_fail;
15841  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpAsPathSegment, 0 | 0 );
15842  if (!SWIG_IsOK(res1)) {
15843  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpAsPathSegment_value_set" "', argument " "1"" of type '" "libbgp::BgpAsPathSegment *""'");
15844  }
15845  arg1 = reinterpret_cast< libbgp::BgpAsPathSegment * >(argp1);
15846  {
15847  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 | 0);
15848  if (!SWIG_IsOK(res2)) {
15849  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpAsPathSegment_value_set" "', argument " "2"" of type '" "std::vector< uint32_t >""'");
15850  }
15851  if (!argp2) {
15852  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpAsPathSegment_value_set" "', argument " "2"" of type '" "std::vector< uint32_t >""'");
15853  } else {
15854  std::vector< uint32_t > * temp = reinterpret_cast< std::vector< uint32_t > * >(argp2);
15855  arg2 = *temp;
15856  if (SWIG_IsNewObj(res2)) delete temp;
15857  }
15858  }
15859  if (arg1) (arg1)->value = arg2;
15860  resultobj = SWIG_Py_Void();
15861  return resultobj;
15862 fail:
15863  return NULL;
15864 }
15865 
15866 
15867 SWIGINTERN PyObject *_wrap_BgpAsPathSegment_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15868  PyObject *resultobj = 0;
15870  void *argp1 = 0 ;
15871  int res1 = 0 ;
15872  PyObject * obj0 = 0 ;
15873  std::vector< uint32_t > result;
15874 
15875  if (!PyArg_ParseTuple(args,(char *)"O:BgpAsPathSegment_value_get",&obj0)) SWIG_fail;
15876  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpAsPathSegment, 0 | 0 );
15877  if (!SWIG_IsOK(res1)) {
15878  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpAsPathSegment_value_get" "', argument " "1"" of type '" "libbgp::BgpAsPathSegment *""'");
15879  }
15880  arg1 = reinterpret_cast< libbgp::BgpAsPathSegment * >(argp1);
15881  result = ((arg1)->value);
15882  resultobj = SWIG_NewPointerObj((new std::vector< uint32_t >(static_cast< const std::vector< uint32_t >& >(result))), SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_POINTER_OWN | 0 );
15883  return resultobj;
15884 fail:
15885  return NULL;
15886 }
15887 
15888 
15889 SWIGINTERN PyObject *_wrap_delete_BgpAsPathSegment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15890  PyObject *resultobj = 0;
15892  void *argp1 = 0 ;
15893  int res1 = 0 ;
15894  PyObject * obj0 = 0 ;
15895 
15896  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpAsPathSegment",&obj0)) SWIG_fail;
15897  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpAsPathSegment, SWIG_POINTER_DISOWN | 0 );
15898  if (!SWIG_IsOK(res1)) {
15899  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpAsPathSegment" "', argument " "1"" of type '" "libbgp::BgpAsPathSegment *""'");
15900  }
15901  arg1 = reinterpret_cast< libbgp::BgpAsPathSegment * >(argp1);
15902  delete arg1;
15903  resultobj = SWIG_Py_Void();
15904  return resultobj;
15905 fail:
15906  return NULL;
15907 }
15908 
15909 
15910 SWIGINTERN PyObject *BgpAsPathSegment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15911  PyObject *obj;
15912  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
15913  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpAsPathSegment, SWIG_NewClientData(obj));
15914  return SWIG_Py_Void();
15915 }
15916 
15917 SWIGINTERN PyObject *_wrap_new_BgpPathAttribAsPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15918  PyObject *resultobj = 0;
15920  bool arg2 ;
15921  void *argp1 = 0 ;
15922  int res1 = 0 ;
15923  bool val2 ;
15924  int ecode2 = 0 ;
15925  PyObject * obj0 = 0 ;
15926  PyObject * obj1 = 0 ;
15927  libbgp::BgpPathAttribAsPath *result = 0 ;
15928 
15929  if (!PyArg_ParseTuple(args,(char *)"OO:new_BgpPathAttribAsPath",&obj0,&obj1)) SWIG_fail;
15930  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
15931  if (!SWIG_IsOK(res1)) {
15932  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribAsPath" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
15933  }
15934  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
15935  ecode2 = SWIG_AsVal_bool(obj1, &val2);
15936  if (!SWIG_IsOK(ecode2)) {
15937  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpPathAttribAsPath" "', argument " "2"" of type '" "bool""'");
15938  }
15939  arg2 = static_cast< bool >(val2);
15940  result = (libbgp::BgpPathAttribAsPath *)new libbgp::BgpPathAttribAsPath(arg1,arg2);
15941  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribAsPath, SWIG_POINTER_NEW | 0 );
15942  return resultobj;
15943 fail:
15944  return NULL;
15945 }
15946 
15947 
15948 SWIGINTERN PyObject *_wrap_BgpPathAttribAsPath_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15949  PyObject *resultobj = 0;
15951  void *argp1 = 0 ;
15952  int res1 = 0 ;
15953  PyObject * obj0 = 0 ;
15954  libbgp::BgpPathAttrib *result = 0 ;
15955 
15956  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAsPath_clone",&obj0)) SWIG_fail;
15957  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAsPath, 0 | 0 );
15958  if (!SWIG_IsOK(res1)) {
15959  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAsPath_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttribAsPath const *""'");
15960  }
15961  arg1 = reinterpret_cast< libbgp::BgpPathAttribAsPath * >(argp1);
15962  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttribAsPath const *)arg1)->clone();
15963  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
15964  return resultobj;
15965 fail:
15966  return NULL;
15967 }
15968 
15969 
15970 SWIGINTERN PyObject *_wrap_BgpPathAttribAsPath_as_paths_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15971  PyObject *resultobj = 0;
15973  std::vector< libbgp::BgpAsPathSegment > *arg2 = (std::vector< libbgp::BgpAsPathSegment > *) 0 ;
15974  void *argp1 = 0 ;
15975  int res1 = 0 ;
15976  void *argp2 = 0 ;
15977  int res2 = 0 ;
15978  PyObject * obj0 = 0 ;
15979  PyObject * obj1 = 0 ;
15980 
15981  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribAsPath_as_paths_set",&obj0,&obj1)) SWIG_fail;
15982  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAsPath, 0 | 0 );
15983  if (!SWIG_IsOK(res1)) {
15984  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAsPath_as_paths_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribAsPath *""'");
15985  }
15986  arg1 = reinterpret_cast< libbgp::BgpPathAttribAsPath * >(argp1);
15987  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_libbgp__BgpAsPathSegment_t, 0 | 0 );
15988  if (!SWIG_IsOK(res2)) {
15989  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribAsPath_as_paths_set" "', argument " "2"" of type '" "std::vector< libbgp::BgpAsPathSegment > *""'");
15990  }
15991  arg2 = reinterpret_cast< std::vector< libbgp::BgpAsPathSegment > * >(argp2);
15992  if (arg1) (arg1)->as_paths = *arg2;
15993  resultobj = SWIG_Py_Void();
15994  return resultobj;
15995 fail:
15996  return NULL;
15997 }
15998 
15999 
16000 SWIGINTERN PyObject *_wrap_BgpPathAttribAsPath_as_paths_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16001  PyObject *resultobj = 0;
16003  void *argp1 = 0 ;
16004  int res1 = 0 ;
16005  PyObject * obj0 = 0 ;
16006  std::vector< libbgp::BgpAsPathSegment > *result = 0 ;
16007 
16008  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAsPath_as_paths_get",&obj0)) SWIG_fail;
16009  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAsPath, 0 | 0 );
16010  if (!SWIG_IsOK(res1)) {
16011  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAsPath_as_paths_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribAsPath *""'");
16012  }
16013  arg1 = reinterpret_cast< libbgp::BgpPathAttribAsPath * >(argp1);
16014  result = (std::vector< libbgp::BgpAsPathSegment > *)& ((arg1)->as_paths);
16015  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_libbgp__BgpAsPathSegment_t, 0 | 0 );
16016  return resultobj;
16017 fail:
16018  return NULL;
16019 }
16020 
16021 
16022 SWIGINTERN PyObject *_wrap_BgpPathAttribAsPath_is_4b_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16023  PyObject *resultobj = 0;
16025  bool arg2 ;
16026  void *argp1 = 0 ;
16027  int res1 = 0 ;
16028  bool val2 ;
16029  int ecode2 = 0 ;
16030  PyObject * obj0 = 0 ;
16031  PyObject * obj1 = 0 ;
16032 
16033  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribAsPath_is_4b_set",&obj0,&obj1)) SWIG_fail;
16034  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAsPath, 0 | 0 );
16035  if (!SWIG_IsOK(res1)) {
16036  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAsPath_is_4b_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribAsPath *""'");
16037  }
16038  arg1 = reinterpret_cast< libbgp::BgpPathAttribAsPath * >(argp1);
16039  ecode2 = SWIG_AsVal_bool(obj1, &val2);
16040  if (!SWIG_IsOK(ecode2)) {
16041  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribAsPath_is_4b_set" "', argument " "2"" of type '" "bool""'");
16042  }
16043  arg2 = static_cast< bool >(val2);
16044  if (arg1) (arg1)->is_4b = arg2;
16045  resultobj = SWIG_Py_Void();
16046  return resultobj;
16047 fail:
16048  return NULL;
16049 }
16050 
16051 
16052 SWIGINTERN PyObject *_wrap_BgpPathAttribAsPath_is_4b_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16053  PyObject *resultobj = 0;
16055  void *argp1 = 0 ;
16056  int res1 = 0 ;
16057  PyObject * obj0 = 0 ;
16058  bool result;
16059 
16060  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAsPath_is_4b_get",&obj0)) SWIG_fail;
16061  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAsPath, 0 | 0 );
16062  if (!SWIG_IsOK(res1)) {
16063  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAsPath_is_4b_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribAsPath *""'");
16064  }
16065  arg1 = reinterpret_cast< libbgp::BgpPathAttribAsPath * >(argp1);
16066  result = (bool) ((arg1)->is_4b);
16067  resultobj = SWIG_From_bool(static_cast< bool >(result));
16068  return resultobj;
16069 fail:
16070  return NULL;
16071 }
16072 
16073 
16074 SWIGINTERN PyObject *_wrap_BgpPathAttribAsPath_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16075  PyObject *resultobj = 0;
16077  uint32_t arg2 ;
16078  void *argp1 = 0 ;
16079  int res1 = 0 ;
16080  unsigned int val2 ;
16081  int ecode2 = 0 ;
16082  PyObject * obj0 = 0 ;
16083  PyObject * obj1 = 0 ;
16084  bool result;
16085 
16086  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribAsPath_prepend",&obj0,&obj1)) SWIG_fail;
16087  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAsPath, 0 | 0 );
16088  if (!SWIG_IsOK(res1)) {
16089  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAsPath_prepend" "', argument " "1"" of type '" "libbgp::BgpPathAttribAsPath *""'");
16090  }
16091  arg1 = reinterpret_cast< libbgp::BgpPathAttribAsPath * >(argp1);
16092  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16093  if (!SWIG_IsOK(ecode2)) {
16094  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribAsPath_prepend" "', argument " "2"" of type '" "uint32_t""'");
16095  }
16096  arg2 = static_cast< uint32_t >(val2);
16097  result = (bool)(arg1)->prepend(arg2);
16098  resultobj = SWIG_From_bool(static_cast< bool >(result));
16099  return resultobj;
16100 fail:
16101  return NULL;
16102 }
16103 
16104 
16105 SWIGINTERN PyObject *_wrap_BgpPathAttribAsPath_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16106  PyObject *resultobj = 0;
16108  uint8_t *arg2 = (uint8_t *) 0 ;
16109  size_t arg3 ;
16110  void *argp1 = 0 ;
16111  int res1 = 0 ;
16112  void *argp2 = 0 ;
16113  int res2 = 0 ;
16114  size_t val3 ;
16115  int ecode3 = 0 ;
16116  PyObject * obj0 = 0 ;
16117  PyObject * obj1 = 0 ;
16118  PyObject * obj2 = 0 ;
16119  ssize_t result;
16120 
16121  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribAsPath_parse",&obj0,&obj1,&obj2)) SWIG_fail;
16122  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAsPath, 0 | 0 );
16123  if (!SWIG_IsOK(res1)) {
16124  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAsPath_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttribAsPath *""'");
16125  }
16126  arg1 = reinterpret_cast< libbgp::BgpPathAttribAsPath * >(argp1);
16127  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
16128  if (!SWIG_IsOK(res2)) {
16129  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribAsPath_parse" "', argument " "2"" of type '" "uint8_t const *""'");
16130  }
16131  arg2 = reinterpret_cast< uint8_t * >(argp2);
16132  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
16133  if (!SWIG_IsOK(ecode3)) {
16134  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribAsPath_parse" "', argument " "3"" of type '" "size_t""'");
16135  }
16136  arg3 = static_cast< size_t >(val3);
16137  result = (arg1)->parse((uint8_t const *)arg2,arg3);
16138  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
16139  return resultobj;
16140 fail:
16141  return NULL;
16142 }
16143 
16144 
16145 SWIGINTERN PyObject *_wrap_BgpPathAttribAsPath_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16146  PyObject *resultobj = 0;
16148  uint8_t *arg2 = (uint8_t *) 0 ;
16149  size_t arg3 ;
16150  void *argp1 = 0 ;
16151  int res1 = 0 ;
16152  void *argp2 = 0 ;
16153  int res2 = 0 ;
16154  size_t val3 ;
16155  int ecode3 = 0 ;
16156  PyObject * obj0 = 0 ;
16157  PyObject * obj1 = 0 ;
16158  PyObject * obj2 = 0 ;
16159  ssize_t result;
16160 
16161  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribAsPath_write",&obj0,&obj1,&obj2)) SWIG_fail;
16162  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAsPath, 0 | 0 );
16163  if (!SWIG_IsOK(res1)) {
16164  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAsPath_write" "', argument " "1"" of type '" "libbgp::BgpPathAttribAsPath const *""'");
16165  }
16166  arg1 = reinterpret_cast< libbgp::BgpPathAttribAsPath * >(argp1);
16167  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
16168  if (!SWIG_IsOK(res2)) {
16169  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribAsPath_write" "', argument " "2"" of type '" "uint8_t *""'");
16170  }
16171  arg2 = reinterpret_cast< uint8_t * >(argp2);
16172  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
16173  if (!SWIG_IsOK(ecode3)) {
16174  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribAsPath_write" "', argument " "3"" of type '" "size_t""'");
16175  }
16176  arg3 = static_cast< size_t >(val3);
16177  result = ((libbgp::BgpPathAttribAsPath const *)arg1)->write(arg2,arg3);
16178  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
16179  return resultobj;
16180 fail:
16181  return NULL;
16182 }
16183 
16184 
16185 SWIGINTERN PyObject *_wrap_BgpPathAttribAsPath_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16186  PyObject *resultobj = 0;
16188  size_t arg2 ;
16189  uint8_t **arg3 = (uint8_t **) 0 ;
16190  size_t *arg4 = (size_t *) 0 ;
16191  void *argp1 = 0 ;
16192  int res1 = 0 ;
16193  size_t val2 ;
16194  int ecode2 = 0 ;
16195  void *argp3 = 0 ;
16196  int res3 = 0 ;
16197  void *argp4 = 0 ;
16198  int res4 = 0 ;
16199  PyObject * obj0 = 0 ;
16200  PyObject * obj1 = 0 ;
16201  PyObject * obj2 = 0 ;
16202  PyObject * obj3 = 0 ;
16203  ssize_t result;
16204 
16205  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttribAsPath_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16206  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAsPath, 0 | 0 );
16207  if (!SWIG_IsOK(res1)) {
16208  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAsPath_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttribAsPath const *""'");
16209  }
16210  arg1 = reinterpret_cast< libbgp::BgpPathAttribAsPath * >(argp1);
16211  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
16212  if (!SWIG_IsOK(ecode2)) {
16213  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribAsPath_doPrint" "', argument " "2"" of type '" "size_t""'");
16214  }
16215  arg2 = static_cast< size_t >(val2);
16216  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
16217  if (!SWIG_IsOK(res3)) {
16218  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttribAsPath_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
16219  }
16220  arg3 = reinterpret_cast< uint8_t ** >(argp3);
16221  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
16222  if (!SWIG_IsOK(res4)) {
16223  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttribAsPath_doPrint" "', argument " "4"" of type '" "size_t *""'");
16224  }
16225  arg4 = reinterpret_cast< size_t * >(argp4);
16226  result = ((libbgp::BgpPathAttribAsPath const *)arg1)->doPrint(arg2,arg3,arg4);
16227  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
16228  return resultobj;
16229 fail:
16230  return NULL;
16231 }
16232 
16233 
16234 SWIGINTERN PyObject *_wrap_BgpPathAttribAsPath_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16235  PyObject *resultobj = 0;
16237  void *argp1 = 0 ;
16238  int res1 = 0 ;
16239  PyObject * obj0 = 0 ;
16240  ssize_t result;
16241 
16242  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAsPath_length",&obj0)) SWIG_fail;
16243  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAsPath, 0 | 0 );
16244  if (!SWIG_IsOK(res1)) {
16245  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAsPath_length" "', argument " "1"" of type '" "libbgp::BgpPathAttribAsPath const *""'");
16246  }
16247  arg1 = reinterpret_cast< libbgp::BgpPathAttribAsPath * >(argp1);
16248  result = ((libbgp::BgpPathAttribAsPath const *)arg1)->length();
16249  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
16250  return resultobj;
16251 fail:
16252  return NULL;
16253 }
16254 
16255 
16256 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribAsPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16257  PyObject *resultobj = 0;
16259  void *argp1 = 0 ;
16260  int res1 = 0 ;
16261  PyObject * obj0 = 0 ;
16262 
16263  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribAsPath",&obj0)) SWIG_fail;
16264  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAsPath, SWIG_POINTER_DISOWN | 0 );
16265  if (!SWIG_IsOK(res1)) {
16266  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribAsPath" "', argument " "1"" of type '" "libbgp::BgpPathAttribAsPath *""'");
16267  }
16268  arg1 = reinterpret_cast< libbgp::BgpPathAttribAsPath * >(argp1);
16269  delete arg1;
16270  resultobj = SWIG_Py_Void();
16271  return resultobj;
16272 fail:
16273  return NULL;
16274 }
16275 
16276 
16277 SWIGINTERN PyObject *BgpPathAttribAsPath_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16278  PyObject *obj;
16279  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
16280  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribAsPath, SWIG_NewClientData(obj));
16281  return SWIG_Py_Void();
16282 }
16283 
16284 SWIGINTERN PyObject *_wrap_new_BgpPathAttribNexthop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16285  PyObject *resultobj = 0;
16287  void *argp1 = 0 ;
16288  int res1 = 0 ;
16289  PyObject * obj0 = 0 ;
16290  libbgp::BgpPathAttribNexthop *result = 0 ;
16291 
16292  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpPathAttribNexthop",&obj0)) SWIG_fail;
16293  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
16294  if (!SWIG_IsOK(res1)) {
16295  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribNexthop" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
16296  }
16297  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
16299  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribNexthop, SWIG_POINTER_NEW | 0 );
16300  return resultobj;
16301 fail:
16302  return NULL;
16303 }
16304 
16305 
16306 SWIGINTERN PyObject *_wrap_BgpPathAttribNexthop_next_hop_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16307  PyObject *resultobj = 0;
16309  uint32_t arg2 ;
16310  void *argp1 = 0 ;
16311  int res1 = 0 ;
16312  unsigned int val2 ;
16313  int ecode2 = 0 ;
16314  PyObject * obj0 = 0 ;
16315  PyObject * obj1 = 0 ;
16316 
16317  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribNexthop_next_hop_set",&obj0,&obj1)) SWIG_fail;
16318  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribNexthop, 0 | 0 );
16319  if (!SWIG_IsOK(res1)) {
16320  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribNexthop_next_hop_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribNexthop *""'");
16321  }
16322  arg1 = reinterpret_cast< libbgp::BgpPathAttribNexthop * >(argp1);
16323  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16324  if (!SWIG_IsOK(ecode2)) {
16325  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribNexthop_next_hop_set" "', argument " "2"" of type '" "uint32_t""'");
16326  }
16327  arg2 = static_cast< uint32_t >(val2);
16328  if (arg1) (arg1)->next_hop = arg2;
16329  resultobj = SWIG_Py_Void();
16330  return resultobj;
16331 fail:
16332  return NULL;
16333 }
16334 
16335 
16336 SWIGINTERN PyObject *_wrap_BgpPathAttribNexthop_next_hop_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16337  PyObject *resultobj = 0;
16339  void *argp1 = 0 ;
16340  int res1 = 0 ;
16341  PyObject * obj0 = 0 ;
16342  uint32_t result;
16343 
16344  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribNexthop_next_hop_get",&obj0)) SWIG_fail;
16345  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribNexthop, 0 | 0 );
16346  if (!SWIG_IsOK(res1)) {
16347  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribNexthop_next_hop_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribNexthop *""'");
16348  }
16349  arg1 = reinterpret_cast< libbgp::BgpPathAttribNexthop * >(argp1);
16350  result = (uint32_t) ((arg1)->next_hop);
16351  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16352  return resultobj;
16353 fail:
16354  return NULL;
16355 }
16356 
16357 
16358 SWIGINTERN PyObject *_wrap_BgpPathAttribNexthop_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16359  PyObject *resultobj = 0;
16361  void *argp1 = 0 ;
16362  int res1 = 0 ;
16363  PyObject * obj0 = 0 ;
16364  libbgp::BgpPathAttrib *result = 0 ;
16365 
16366  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribNexthop_clone",&obj0)) SWIG_fail;
16367  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribNexthop, 0 | 0 );
16368  if (!SWIG_IsOK(res1)) {
16369  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribNexthop_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttribNexthop const *""'");
16370  }
16371  arg1 = reinterpret_cast< libbgp::BgpPathAttribNexthop * >(argp1);
16372  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttribNexthop const *)arg1)->clone();
16373  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
16374  return resultobj;
16375 fail:
16376  return NULL;
16377 }
16378 
16379 
16380 SWIGINTERN PyObject *_wrap_BgpPathAttribNexthop_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16381  PyObject *resultobj = 0;
16383  uint8_t *arg2 = (uint8_t *) 0 ;
16384  size_t arg3 ;
16385  void *argp1 = 0 ;
16386  int res1 = 0 ;
16387  void *argp2 = 0 ;
16388  int res2 = 0 ;
16389  size_t val3 ;
16390  int ecode3 = 0 ;
16391  PyObject * obj0 = 0 ;
16392  PyObject * obj1 = 0 ;
16393  PyObject * obj2 = 0 ;
16394  ssize_t result;
16395 
16396  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribNexthop_parse",&obj0,&obj1,&obj2)) SWIG_fail;
16397  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribNexthop, 0 | 0 );
16398  if (!SWIG_IsOK(res1)) {
16399  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribNexthop_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttribNexthop *""'");
16400  }
16401  arg1 = reinterpret_cast< libbgp::BgpPathAttribNexthop * >(argp1);
16402  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
16403  if (!SWIG_IsOK(res2)) {
16404  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribNexthop_parse" "', argument " "2"" of type '" "uint8_t const *""'");
16405  }
16406  arg2 = reinterpret_cast< uint8_t * >(argp2);
16407  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
16408  if (!SWIG_IsOK(ecode3)) {
16409  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribNexthop_parse" "', argument " "3"" of type '" "size_t""'");
16410  }
16411  arg3 = static_cast< size_t >(val3);
16412  result = (arg1)->parse((uint8_t const *)arg2,arg3);
16413  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
16414  return resultobj;
16415 fail:
16416  return NULL;
16417 }
16418 
16419 
16420 SWIGINTERN PyObject *_wrap_BgpPathAttribNexthop_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16421  PyObject *resultobj = 0;
16423  uint8_t *arg2 = (uint8_t *) 0 ;
16424  size_t arg3 ;
16425  void *argp1 = 0 ;
16426  int res1 = 0 ;
16427  void *argp2 = 0 ;
16428  int res2 = 0 ;
16429  size_t val3 ;
16430  int ecode3 = 0 ;
16431  PyObject * obj0 = 0 ;
16432  PyObject * obj1 = 0 ;
16433  PyObject * obj2 = 0 ;
16434  ssize_t result;
16435 
16436  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribNexthop_write",&obj0,&obj1,&obj2)) SWIG_fail;
16437  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribNexthop, 0 | 0 );
16438  if (!SWIG_IsOK(res1)) {
16439  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribNexthop_write" "', argument " "1"" of type '" "libbgp::BgpPathAttribNexthop const *""'");
16440  }
16441  arg1 = reinterpret_cast< libbgp::BgpPathAttribNexthop * >(argp1);
16442  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
16443  if (!SWIG_IsOK(res2)) {
16444  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribNexthop_write" "', argument " "2"" of type '" "uint8_t *""'");
16445  }
16446  arg2 = reinterpret_cast< uint8_t * >(argp2);
16447  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
16448  if (!SWIG_IsOK(ecode3)) {
16449  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribNexthop_write" "', argument " "3"" of type '" "size_t""'");
16450  }
16451  arg3 = static_cast< size_t >(val3);
16452  result = ((libbgp::BgpPathAttribNexthop const *)arg1)->write(arg2,arg3);
16453  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
16454  return resultobj;
16455 fail:
16456  return NULL;
16457 }
16458 
16459 
16460 SWIGINTERN PyObject *_wrap_BgpPathAttribNexthop_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16461  PyObject *resultobj = 0;
16463  size_t arg2 ;
16464  uint8_t **arg3 = (uint8_t **) 0 ;
16465  size_t *arg4 = (size_t *) 0 ;
16466  void *argp1 = 0 ;
16467  int res1 = 0 ;
16468  size_t val2 ;
16469  int ecode2 = 0 ;
16470  void *argp3 = 0 ;
16471  int res3 = 0 ;
16472  void *argp4 = 0 ;
16473  int res4 = 0 ;
16474  PyObject * obj0 = 0 ;
16475  PyObject * obj1 = 0 ;
16476  PyObject * obj2 = 0 ;
16477  PyObject * obj3 = 0 ;
16478  ssize_t result;
16479 
16480  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttribNexthop_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16481  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribNexthop, 0 | 0 );
16482  if (!SWIG_IsOK(res1)) {
16483  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribNexthop_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttribNexthop const *""'");
16484  }
16485  arg1 = reinterpret_cast< libbgp::BgpPathAttribNexthop * >(argp1);
16486  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
16487  if (!SWIG_IsOK(ecode2)) {
16488  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribNexthop_doPrint" "', argument " "2"" of type '" "size_t""'");
16489  }
16490  arg2 = static_cast< size_t >(val2);
16491  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
16492  if (!SWIG_IsOK(res3)) {
16493  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttribNexthop_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
16494  }
16495  arg3 = reinterpret_cast< uint8_t ** >(argp3);
16496  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
16497  if (!SWIG_IsOK(res4)) {
16498  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttribNexthop_doPrint" "', argument " "4"" of type '" "size_t *""'");
16499  }
16500  arg4 = reinterpret_cast< size_t * >(argp4);
16501  result = ((libbgp::BgpPathAttribNexthop const *)arg1)->doPrint(arg2,arg3,arg4);
16502  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
16503  return resultobj;
16504 fail:
16505  return NULL;
16506 }
16507 
16508 
16509 SWIGINTERN PyObject *_wrap_BgpPathAttribNexthop_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16510  PyObject *resultobj = 0;
16512  void *argp1 = 0 ;
16513  int res1 = 0 ;
16514  PyObject * obj0 = 0 ;
16515  ssize_t result;
16516 
16517  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribNexthop_length",&obj0)) SWIG_fail;
16518  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribNexthop, 0 | 0 );
16519  if (!SWIG_IsOK(res1)) {
16520  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribNexthop_length" "', argument " "1"" of type '" "libbgp::BgpPathAttribNexthop const *""'");
16521  }
16522  arg1 = reinterpret_cast< libbgp::BgpPathAttribNexthop * >(argp1);
16523  result = ((libbgp::BgpPathAttribNexthop const *)arg1)->length();
16524  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
16525  return resultobj;
16526 fail:
16527  return NULL;
16528 }
16529 
16530 
16531 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribNexthop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16532  PyObject *resultobj = 0;
16534  void *argp1 = 0 ;
16535  int res1 = 0 ;
16536  PyObject * obj0 = 0 ;
16537 
16538  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribNexthop",&obj0)) SWIG_fail;
16539  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribNexthop, SWIG_POINTER_DISOWN | 0 );
16540  if (!SWIG_IsOK(res1)) {
16541  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribNexthop" "', argument " "1"" of type '" "libbgp::BgpPathAttribNexthop *""'");
16542  }
16543  arg1 = reinterpret_cast< libbgp::BgpPathAttribNexthop * >(argp1);
16544  delete arg1;
16545  resultobj = SWIG_Py_Void();
16546  return resultobj;
16547 fail:
16548  return NULL;
16549 }
16550 
16551 
16552 SWIGINTERN PyObject *BgpPathAttribNexthop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16553  PyObject *obj;
16554  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
16555  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribNexthop, SWIG_NewClientData(obj));
16556  return SWIG_Py_Void();
16557 }
16558 
16559 SWIGINTERN PyObject *_wrap_new_BgpPathAttribMed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16560  PyObject *resultobj = 0;
16562  void *argp1 = 0 ;
16563  int res1 = 0 ;
16564  PyObject * obj0 = 0 ;
16565  libbgp::BgpPathAttribMed *result = 0 ;
16566 
16567  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpPathAttribMed",&obj0)) SWIG_fail;
16568  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
16569  if (!SWIG_IsOK(res1)) {
16570  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribMed" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
16571  }
16572  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
16573  result = (libbgp::BgpPathAttribMed *)new libbgp::BgpPathAttribMed(arg1);
16574  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribMed, SWIG_POINTER_NEW | 0 );
16575  return resultobj;
16576 fail:
16577  return NULL;
16578 }
16579 
16580 
16581 SWIGINTERN PyObject *_wrap_BgpPathAttribMed_med_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16582  PyObject *resultobj = 0;
16584  uint32_t arg2 ;
16585  void *argp1 = 0 ;
16586  int res1 = 0 ;
16587  unsigned int val2 ;
16588  int ecode2 = 0 ;
16589  PyObject * obj0 = 0 ;
16590  PyObject * obj1 = 0 ;
16591 
16592  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribMed_med_set",&obj0,&obj1)) SWIG_fail;
16593  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMed, 0 | 0 );
16594  if (!SWIG_IsOK(res1)) {
16595  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMed_med_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribMed *""'");
16596  }
16597  arg1 = reinterpret_cast< libbgp::BgpPathAttribMed * >(argp1);
16598  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16599  if (!SWIG_IsOK(ecode2)) {
16600  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribMed_med_set" "', argument " "2"" of type '" "uint32_t""'");
16601  }
16602  arg2 = static_cast< uint32_t >(val2);
16603  if (arg1) (arg1)->med = arg2;
16604  resultobj = SWIG_Py_Void();
16605  return resultobj;
16606 fail:
16607  return NULL;
16608 }
16609 
16610 
16611 SWIGINTERN PyObject *_wrap_BgpPathAttribMed_med_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16612  PyObject *resultobj = 0;
16614  void *argp1 = 0 ;
16615  int res1 = 0 ;
16616  PyObject * obj0 = 0 ;
16617  uint32_t result;
16618 
16619  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMed_med_get",&obj0)) SWIG_fail;
16620  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMed, 0 | 0 );
16621  if (!SWIG_IsOK(res1)) {
16622  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMed_med_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribMed *""'");
16623  }
16624  arg1 = reinterpret_cast< libbgp::BgpPathAttribMed * >(argp1);
16625  result = (uint32_t) ((arg1)->med);
16626  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16627  return resultobj;
16628 fail:
16629  return NULL;
16630 }
16631 
16632 
16633 SWIGINTERN PyObject *_wrap_BgpPathAttribMed_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16634  PyObject *resultobj = 0;
16636  void *argp1 = 0 ;
16637  int res1 = 0 ;
16638  PyObject * obj0 = 0 ;
16639  libbgp::BgpPathAttrib *result = 0 ;
16640 
16641  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMed_clone",&obj0)) SWIG_fail;
16642  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMed, 0 | 0 );
16643  if (!SWIG_IsOK(res1)) {
16644  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMed_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttribMed const *""'");
16645  }
16646  arg1 = reinterpret_cast< libbgp::BgpPathAttribMed * >(argp1);
16647  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttribMed const *)arg1)->clone();
16648  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
16649  return resultobj;
16650 fail:
16651  return NULL;
16652 }
16653 
16654 
16655 SWIGINTERN PyObject *_wrap_BgpPathAttribMed_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16656  PyObject *resultobj = 0;
16658  uint8_t *arg2 = (uint8_t *) 0 ;
16659  size_t arg3 ;
16660  void *argp1 = 0 ;
16661  int res1 = 0 ;
16662  void *argp2 = 0 ;
16663  int res2 = 0 ;
16664  size_t val3 ;
16665  int ecode3 = 0 ;
16666  PyObject * obj0 = 0 ;
16667  PyObject * obj1 = 0 ;
16668  PyObject * obj2 = 0 ;
16669  ssize_t result;
16670 
16671  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribMed_parse",&obj0,&obj1,&obj2)) SWIG_fail;
16672  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMed, 0 | 0 );
16673  if (!SWIG_IsOK(res1)) {
16674  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMed_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttribMed *""'");
16675  }
16676  arg1 = reinterpret_cast< libbgp::BgpPathAttribMed * >(argp1);
16677  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
16678  if (!SWIG_IsOK(res2)) {
16679  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribMed_parse" "', argument " "2"" of type '" "uint8_t const *""'");
16680  }
16681  arg2 = reinterpret_cast< uint8_t * >(argp2);
16682  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
16683  if (!SWIG_IsOK(ecode3)) {
16684  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribMed_parse" "', argument " "3"" of type '" "size_t""'");
16685  }
16686  arg3 = static_cast< size_t >(val3);
16687  result = (arg1)->parse((uint8_t const *)arg2,arg3);
16688  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
16689  return resultobj;
16690 fail:
16691  return NULL;
16692 }
16693 
16694 
16695 SWIGINTERN PyObject *_wrap_BgpPathAttribMed_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16696  PyObject *resultobj = 0;
16698  uint8_t *arg2 = (uint8_t *) 0 ;
16699  size_t arg3 ;
16700  void *argp1 = 0 ;
16701  int res1 = 0 ;
16702  void *argp2 = 0 ;
16703  int res2 = 0 ;
16704  size_t val3 ;
16705  int ecode3 = 0 ;
16706  PyObject * obj0 = 0 ;
16707  PyObject * obj1 = 0 ;
16708  PyObject * obj2 = 0 ;
16709  ssize_t result;
16710 
16711  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribMed_write",&obj0,&obj1,&obj2)) SWIG_fail;
16712  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMed, 0 | 0 );
16713  if (!SWIG_IsOK(res1)) {
16714  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMed_write" "', argument " "1"" of type '" "libbgp::BgpPathAttribMed const *""'");
16715  }
16716  arg1 = reinterpret_cast< libbgp::BgpPathAttribMed * >(argp1);
16717  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
16718  if (!SWIG_IsOK(res2)) {
16719  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribMed_write" "', argument " "2"" of type '" "uint8_t *""'");
16720  }
16721  arg2 = reinterpret_cast< uint8_t * >(argp2);
16722  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
16723  if (!SWIG_IsOK(ecode3)) {
16724  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribMed_write" "', argument " "3"" of type '" "size_t""'");
16725  }
16726  arg3 = static_cast< size_t >(val3);
16727  result = ((libbgp::BgpPathAttribMed const *)arg1)->write(arg2,arg3);
16728  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
16729  return resultobj;
16730 fail:
16731  return NULL;
16732 }
16733 
16734 
16735 SWIGINTERN PyObject *_wrap_BgpPathAttribMed_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16736  PyObject *resultobj = 0;
16738  size_t arg2 ;
16739  uint8_t **arg3 = (uint8_t **) 0 ;
16740  size_t *arg4 = (size_t *) 0 ;
16741  void *argp1 = 0 ;
16742  int res1 = 0 ;
16743  size_t val2 ;
16744  int ecode2 = 0 ;
16745  void *argp3 = 0 ;
16746  int res3 = 0 ;
16747  void *argp4 = 0 ;
16748  int res4 = 0 ;
16749  PyObject * obj0 = 0 ;
16750  PyObject * obj1 = 0 ;
16751  PyObject * obj2 = 0 ;
16752  PyObject * obj3 = 0 ;
16753  ssize_t result;
16754 
16755  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttribMed_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16756  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMed, 0 | 0 );
16757  if (!SWIG_IsOK(res1)) {
16758  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMed_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttribMed const *""'");
16759  }
16760  arg1 = reinterpret_cast< libbgp::BgpPathAttribMed * >(argp1);
16761  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
16762  if (!SWIG_IsOK(ecode2)) {
16763  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribMed_doPrint" "', argument " "2"" of type '" "size_t""'");
16764  }
16765  arg2 = static_cast< size_t >(val2);
16766  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
16767  if (!SWIG_IsOK(res3)) {
16768  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttribMed_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
16769  }
16770  arg3 = reinterpret_cast< uint8_t ** >(argp3);
16771  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
16772  if (!SWIG_IsOK(res4)) {
16773  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttribMed_doPrint" "', argument " "4"" of type '" "size_t *""'");
16774  }
16775  arg4 = reinterpret_cast< size_t * >(argp4);
16776  result = ((libbgp::BgpPathAttribMed const *)arg1)->doPrint(arg2,arg3,arg4);
16777  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
16778  return resultobj;
16779 fail:
16780  return NULL;
16781 }
16782 
16783 
16784 SWIGINTERN PyObject *_wrap_BgpPathAttribMed_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16785  PyObject *resultobj = 0;
16787  void *argp1 = 0 ;
16788  int res1 = 0 ;
16789  PyObject * obj0 = 0 ;
16790  ssize_t result;
16791 
16792  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMed_length",&obj0)) SWIG_fail;
16793  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMed, 0 | 0 );
16794  if (!SWIG_IsOK(res1)) {
16795  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMed_length" "', argument " "1"" of type '" "libbgp::BgpPathAttribMed const *""'");
16796  }
16797  arg1 = reinterpret_cast< libbgp::BgpPathAttribMed * >(argp1);
16798  result = ((libbgp::BgpPathAttribMed const *)arg1)->length();
16799  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
16800  return resultobj;
16801 fail:
16802  return NULL;
16803 }
16804 
16805 
16806 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribMed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16807  PyObject *resultobj = 0;
16809  void *argp1 = 0 ;
16810  int res1 = 0 ;
16811  PyObject * obj0 = 0 ;
16812 
16813  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribMed",&obj0)) SWIG_fail;
16814  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMed, SWIG_POINTER_DISOWN | 0 );
16815  if (!SWIG_IsOK(res1)) {
16816  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribMed" "', argument " "1"" of type '" "libbgp::BgpPathAttribMed *""'");
16817  }
16818  arg1 = reinterpret_cast< libbgp::BgpPathAttribMed * >(argp1);
16819  delete arg1;
16820  resultobj = SWIG_Py_Void();
16821  return resultobj;
16822 fail:
16823  return NULL;
16824 }
16825 
16826 
16827 SWIGINTERN PyObject *BgpPathAttribMed_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16828  PyObject *obj;
16829  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
16830  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribMed, SWIG_NewClientData(obj));
16831  return SWIG_Py_Void();
16832 }
16833 
16834 SWIGINTERN PyObject *_wrap_new_BgpPathAttribLocalPref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16835  PyObject *resultobj = 0;
16837  void *argp1 = 0 ;
16838  int res1 = 0 ;
16839  PyObject * obj0 = 0 ;
16840  libbgp::BgpPathAttribLocalPref *result = 0 ;
16841 
16842  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpPathAttribLocalPref",&obj0)) SWIG_fail;
16843  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
16844  if (!SWIG_IsOK(res1)) {
16845  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribLocalPref" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
16846  }
16847  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
16849  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribLocalPref, SWIG_POINTER_NEW | 0 );
16850  return resultobj;
16851 fail:
16852  return NULL;
16853 }
16854 
16855 
16856 SWIGINTERN PyObject *_wrap_BgpPathAttribLocalPref_local_pref_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16857  PyObject *resultobj = 0;
16859  uint32_t arg2 ;
16860  void *argp1 = 0 ;
16861  int res1 = 0 ;
16862  unsigned int val2 ;
16863  int ecode2 = 0 ;
16864  PyObject * obj0 = 0 ;
16865  PyObject * obj1 = 0 ;
16866 
16867  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribLocalPref_local_pref_set",&obj0,&obj1)) SWIG_fail;
16868  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribLocalPref, 0 | 0 );
16869  if (!SWIG_IsOK(res1)) {
16870  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribLocalPref_local_pref_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribLocalPref *""'");
16871  }
16872  arg1 = reinterpret_cast< libbgp::BgpPathAttribLocalPref * >(argp1);
16873  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16874  if (!SWIG_IsOK(ecode2)) {
16875  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribLocalPref_local_pref_set" "', argument " "2"" of type '" "uint32_t""'");
16876  }
16877  arg2 = static_cast< uint32_t >(val2);
16878  if (arg1) (arg1)->local_pref = arg2;
16879  resultobj = SWIG_Py_Void();
16880  return resultobj;
16881 fail:
16882  return NULL;
16883 }
16884 
16885 
16886 SWIGINTERN PyObject *_wrap_BgpPathAttribLocalPref_local_pref_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16887  PyObject *resultobj = 0;
16889  void *argp1 = 0 ;
16890  int res1 = 0 ;
16891  PyObject * obj0 = 0 ;
16892  uint32_t result;
16893 
16894  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribLocalPref_local_pref_get",&obj0)) SWIG_fail;
16895  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribLocalPref, 0 | 0 );
16896  if (!SWIG_IsOK(res1)) {
16897  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribLocalPref_local_pref_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribLocalPref *""'");
16898  }
16899  arg1 = reinterpret_cast< libbgp::BgpPathAttribLocalPref * >(argp1);
16900  result = (uint32_t) ((arg1)->local_pref);
16901  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16902  return resultobj;
16903 fail:
16904  return NULL;
16905 }
16906 
16907 
16908 SWIGINTERN PyObject *_wrap_BgpPathAttribLocalPref_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16909  PyObject *resultobj = 0;
16911  void *argp1 = 0 ;
16912  int res1 = 0 ;
16913  PyObject * obj0 = 0 ;
16914  libbgp::BgpPathAttrib *result = 0 ;
16915 
16916  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribLocalPref_clone",&obj0)) SWIG_fail;
16917  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribLocalPref, 0 | 0 );
16918  if (!SWIG_IsOK(res1)) {
16919  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribLocalPref_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttribLocalPref const *""'");
16920  }
16921  arg1 = reinterpret_cast< libbgp::BgpPathAttribLocalPref * >(argp1);
16922  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttribLocalPref const *)arg1)->clone();
16923  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
16924  return resultobj;
16925 fail:
16926  return NULL;
16927 }
16928 
16929 
16930 SWIGINTERN PyObject *_wrap_BgpPathAttribLocalPref_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16931  PyObject *resultobj = 0;
16933  uint8_t *arg2 = (uint8_t *) 0 ;
16934  size_t arg3 ;
16935  void *argp1 = 0 ;
16936  int res1 = 0 ;
16937  void *argp2 = 0 ;
16938  int res2 = 0 ;
16939  size_t val3 ;
16940  int ecode3 = 0 ;
16941  PyObject * obj0 = 0 ;
16942  PyObject * obj1 = 0 ;
16943  PyObject * obj2 = 0 ;
16944  ssize_t result;
16945 
16946  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribLocalPref_parse",&obj0,&obj1,&obj2)) SWIG_fail;
16947  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribLocalPref, 0 | 0 );
16948  if (!SWIG_IsOK(res1)) {
16949  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribLocalPref_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttribLocalPref *""'");
16950  }
16951  arg1 = reinterpret_cast< libbgp::BgpPathAttribLocalPref * >(argp1);
16952  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
16953  if (!SWIG_IsOK(res2)) {
16954  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribLocalPref_parse" "', argument " "2"" of type '" "uint8_t const *""'");
16955  }
16956  arg2 = reinterpret_cast< uint8_t * >(argp2);
16957  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
16958  if (!SWIG_IsOK(ecode3)) {
16959  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribLocalPref_parse" "', argument " "3"" of type '" "size_t""'");
16960  }
16961  arg3 = static_cast< size_t >(val3);
16962  result = (arg1)->parse((uint8_t const *)arg2,arg3);
16963  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
16964  return resultobj;
16965 fail:
16966  return NULL;
16967 }
16968 
16969 
16970 SWIGINTERN PyObject *_wrap_BgpPathAttribLocalPref_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16971  PyObject *resultobj = 0;
16973  uint8_t *arg2 = (uint8_t *) 0 ;
16974  size_t arg3 ;
16975  void *argp1 = 0 ;
16976  int res1 = 0 ;
16977  void *argp2 = 0 ;
16978  int res2 = 0 ;
16979  size_t val3 ;
16980  int ecode3 = 0 ;
16981  PyObject * obj0 = 0 ;
16982  PyObject * obj1 = 0 ;
16983  PyObject * obj2 = 0 ;
16984  ssize_t result;
16985 
16986  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribLocalPref_write",&obj0,&obj1,&obj2)) SWIG_fail;
16987  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribLocalPref, 0 | 0 );
16988  if (!SWIG_IsOK(res1)) {
16989  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribLocalPref_write" "', argument " "1"" of type '" "libbgp::BgpPathAttribLocalPref const *""'");
16990  }
16991  arg1 = reinterpret_cast< libbgp::BgpPathAttribLocalPref * >(argp1);
16992  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
16993  if (!SWIG_IsOK(res2)) {
16994  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribLocalPref_write" "', argument " "2"" of type '" "uint8_t *""'");
16995  }
16996  arg2 = reinterpret_cast< uint8_t * >(argp2);
16997  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
16998  if (!SWIG_IsOK(ecode3)) {
16999  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribLocalPref_write" "', argument " "3"" of type '" "size_t""'");
17000  }
17001  arg3 = static_cast< size_t >(val3);
17002  result = ((libbgp::BgpPathAttribLocalPref const *)arg1)->write(arg2,arg3);
17003  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17004  return resultobj;
17005 fail:
17006  return NULL;
17007 }
17008 
17009 
17010 SWIGINTERN PyObject *_wrap_BgpPathAttribLocalPref_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17011  PyObject *resultobj = 0;
17013  size_t arg2 ;
17014  uint8_t **arg3 = (uint8_t **) 0 ;
17015  size_t *arg4 = (size_t *) 0 ;
17016  void *argp1 = 0 ;
17017  int res1 = 0 ;
17018  size_t val2 ;
17019  int ecode2 = 0 ;
17020  void *argp3 = 0 ;
17021  int res3 = 0 ;
17022  void *argp4 = 0 ;
17023  int res4 = 0 ;
17024  PyObject * obj0 = 0 ;
17025  PyObject * obj1 = 0 ;
17026  PyObject * obj2 = 0 ;
17027  PyObject * obj3 = 0 ;
17028  ssize_t result;
17029 
17030  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttribLocalPref_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17031  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribLocalPref, 0 | 0 );
17032  if (!SWIG_IsOK(res1)) {
17033  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribLocalPref_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttribLocalPref const *""'");
17034  }
17035  arg1 = reinterpret_cast< libbgp::BgpPathAttribLocalPref * >(argp1);
17036  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17037  if (!SWIG_IsOK(ecode2)) {
17038  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribLocalPref_doPrint" "', argument " "2"" of type '" "size_t""'");
17039  }
17040  arg2 = static_cast< size_t >(val2);
17041  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
17042  if (!SWIG_IsOK(res3)) {
17043  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttribLocalPref_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
17044  }
17045  arg3 = reinterpret_cast< uint8_t ** >(argp3);
17046  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
17047  if (!SWIG_IsOK(res4)) {
17048  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttribLocalPref_doPrint" "', argument " "4"" of type '" "size_t *""'");
17049  }
17050  arg4 = reinterpret_cast< size_t * >(argp4);
17051  result = ((libbgp::BgpPathAttribLocalPref const *)arg1)->doPrint(arg2,arg3,arg4);
17052  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17053  return resultobj;
17054 fail:
17055  return NULL;
17056 }
17057 
17058 
17059 SWIGINTERN PyObject *_wrap_BgpPathAttribLocalPref_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17060  PyObject *resultobj = 0;
17062  void *argp1 = 0 ;
17063  int res1 = 0 ;
17064  PyObject * obj0 = 0 ;
17065  ssize_t result;
17066 
17067  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribLocalPref_length",&obj0)) SWIG_fail;
17068  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribLocalPref, 0 | 0 );
17069  if (!SWIG_IsOK(res1)) {
17070  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribLocalPref_length" "', argument " "1"" of type '" "libbgp::BgpPathAttribLocalPref const *""'");
17071  }
17072  arg1 = reinterpret_cast< libbgp::BgpPathAttribLocalPref * >(argp1);
17073  result = ((libbgp::BgpPathAttribLocalPref const *)arg1)->length();
17074  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17075  return resultobj;
17076 fail:
17077  return NULL;
17078 }
17079 
17080 
17081 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribLocalPref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17082  PyObject *resultobj = 0;
17084  void *argp1 = 0 ;
17085  int res1 = 0 ;
17086  PyObject * obj0 = 0 ;
17087 
17088  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribLocalPref",&obj0)) SWIG_fail;
17089  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribLocalPref, SWIG_POINTER_DISOWN | 0 );
17090  if (!SWIG_IsOK(res1)) {
17091  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribLocalPref" "', argument " "1"" of type '" "libbgp::BgpPathAttribLocalPref *""'");
17092  }
17093  arg1 = reinterpret_cast< libbgp::BgpPathAttribLocalPref * >(argp1);
17094  delete arg1;
17095  resultobj = SWIG_Py_Void();
17096  return resultobj;
17097 fail:
17098  return NULL;
17099 }
17100 
17101 
17102 SWIGINTERN PyObject *BgpPathAttribLocalPref_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17103  PyObject *obj;
17104  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
17105  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribLocalPref, SWIG_NewClientData(obj));
17106  return SWIG_Py_Void();
17107 }
17108 
17109 SWIGINTERN PyObject *_wrap_new_BgpPathAttribAtomicAggregate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17110  PyObject *resultobj = 0;
17112  void *argp1 = 0 ;
17113  int res1 = 0 ;
17114  PyObject * obj0 = 0 ;
17116 
17117  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpPathAttribAtomicAggregate",&obj0)) SWIG_fail;
17118  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
17119  if (!SWIG_IsOK(res1)) {
17120  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribAtomicAggregate" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
17121  }
17122  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
17124  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribAtomicAggregate, SWIG_POINTER_NEW | 0 );
17125  return resultobj;
17126 fail:
17127  return NULL;
17128 }
17129 
17130 
17131 SWIGINTERN PyObject *_wrap_BgpPathAttribAtomicAggregate_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17132  PyObject *resultobj = 0;
17134  void *argp1 = 0 ;
17135  int res1 = 0 ;
17136  PyObject * obj0 = 0 ;
17137  libbgp::BgpPathAttrib *result = 0 ;
17138 
17139  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAtomicAggregate_clone",&obj0)) SWIG_fail;
17140  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAtomicAggregate, 0 | 0 );
17141  if (!SWIG_IsOK(res1)) {
17142  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAtomicAggregate_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttribAtomicAggregate const *""'");
17143  }
17144  arg1 = reinterpret_cast< libbgp::BgpPathAttribAtomicAggregate * >(argp1);
17145  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttribAtomicAggregate const *)arg1)->clone();
17146  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
17147  return resultobj;
17148 fail:
17149  return NULL;
17150 }
17151 
17152 
17153 SWIGINTERN PyObject *_wrap_BgpPathAttribAtomicAggregate_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17154  PyObject *resultobj = 0;
17156  uint8_t *arg2 = (uint8_t *) 0 ;
17157  size_t arg3 ;
17158  void *argp1 = 0 ;
17159  int res1 = 0 ;
17160  void *argp2 = 0 ;
17161  int res2 = 0 ;
17162  size_t val3 ;
17163  int ecode3 = 0 ;
17164  PyObject * obj0 = 0 ;
17165  PyObject * obj1 = 0 ;
17166  PyObject * obj2 = 0 ;
17167  ssize_t result;
17168 
17169  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribAtomicAggregate_parse",&obj0,&obj1,&obj2)) SWIG_fail;
17170  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAtomicAggregate, 0 | 0 );
17171  if (!SWIG_IsOK(res1)) {
17172  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAtomicAggregate_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttribAtomicAggregate *""'");
17173  }
17174  arg1 = reinterpret_cast< libbgp::BgpPathAttribAtomicAggregate * >(argp1);
17175  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
17176  if (!SWIG_IsOK(res2)) {
17177  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribAtomicAggregate_parse" "', argument " "2"" of type '" "uint8_t const *""'");
17178  }
17179  arg2 = reinterpret_cast< uint8_t * >(argp2);
17180  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
17181  if (!SWIG_IsOK(ecode3)) {
17182  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribAtomicAggregate_parse" "', argument " "3"" of type '" "size_t""'");
17183  }
17184  arg3 = static_cast< size_t >(val3);
17185  result = (arg1)->parse((uint8_t const *)arg2,arg3);
17186  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17187  return resultobj;
17188 fail:
17189  return NULL;
17190 }
17191 
17192 
17193 SWIGINTERN PyObject *_wrap_BgpPathAttribAtomicAggregate_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17194  PyObject *resultobj = 0;
17196  uint8_t *arg2 = (uint8_t *) 0 ;
17197  size_t arg3 ;
17198  void *argp1 = 0 ;
17199  int res1 = 0 ;
17200  void *argp2 = 0 ;
17201  int res2 = 0 ;
17202  size_t val3 ;
17203  int ecode3 = 0 ;
17204  PyObject * obj0 = 0 ;
17205  PyObject * obj1 = 0 ;
17206  PyObject * obj2 = 0 ;
17207  ssize_t result;
17208 
17209  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribAtomicAggregate_write",&obj0,&obj1,&obj2)) SWIG_fail;
17210  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAtomicAggregate, 0 | 0 );
17211  if (!SWIG_IsOK(res1)) {
17212  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAtomicAggregate_write" "', argument " "1"" of type '" "libbgp::BgpPathAttribAtomicAggregate const *""'");
17213  }
17214  arg1 = reinterpret_cast< libbgp::BgpPathAttribAtomicAggregate * >(argp1);
17215  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
17216  if (!SWIG_IsOK(res2)) {
17217  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribAtomicAggregate_write" "', argument " "2"" of type '" "uint8_t *""'");
17218  }
17219  arg2 = reinterpret_cast< uint8_t * >(argp2);
17220  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
17221  if (!SWIG_IsOK(ecode3)) {
17222  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribAtomicAggregate_write" "', argument " "3"" of type '" "size_t""'");
17223  }
17224  arg3 = static_cast< size_t >(val3);
17225  result = ((libbgp::BgpPathAttribAtomicAggregate const *)arg1)->write(arg2,arg3);
17226  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17227  return resultobj;
17228 fail:
17229  return NULL;
17230 }
17231 
17232 
17233 SWIGINTERN PyObject *_wrap_BgpPathAttribAtomicAggregate_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17234  PyObject *resultobj = 0;
17236  size_t arg2 ;
17237  uint8_t **arg3 = (uint8_t **) 0 ;
17238  size_t *arg4 = (size_t *) 0 ;
17239  void *argp1 = 0 ;
17240  int res1 = 0 ;
17241  size_t val2 ;
17242  int ecode2 = 0 ;
17243  void *argp3 = 0 ;
17244  int res3 = 0 ;
17245  void *argp4 = 0 ;
17246  int res4 = 0 ;
17247  PyObject * obj0 = 0 ;
17248  PyObject * obj1 = 0 ;
17249  PyObject * obj2 = 0 ;
17250  PyObject * obj3 = 0 ;
17251  ssize_t result;
17252 
17253  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttribAtomicAggregate_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17254  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAtomicAggregate, 0 | 0 );
17255  if (!SWIG_IsOK(res1)) {
17256  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAtomicAggregate_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttribAtomicAggregate const *""'");
17257  }
17258  arg1 = reinterpret_cast< libbgp::BgpPathAttribAtomicAggregate * >(argp1);
17259  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17260  if (!SWIG_IsOK(ecode2)) {
17261  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribAtomicAggregate_doPrint" "', argument " "2"" of type '" "size_t""'");
17262  }
17263  arg2 = static_cast< size_t >(val2);
17264  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
17265  if (!SWIG_IsOK(res3)) {
17266  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttribAtomicAggregate_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
17267  }
17268  arg3 = reinterpret_cast< uint8_t ** >(argp3);
17269  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
17270  if (!SWIG_IsOK(res4)) {
17271  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttribAtomicAggregate_doPrint" "', argument " "4"" of type '" "size_t *""'");
17272  }
17273  arg4 = reinterpret_cast< size_t * >(argp4);
17274  result = ((libbgp::BgpPathAttribAtomicAggregate const *)arg1)->doPrint(arg2,arg3,arg4);
17275  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17276  return resultobj;
17277 fail:
17278  return NULL;
17279 }
17280 
17281 
17282 SWIGINTERN PyObject *_wrap_BgpPathAttribAtomicAggregate_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17283  PyObject *resultobj = 0;
17285  void *argp1 = 0 ;
17286  int res1 = 0 ;
17287  PyObject * obj0 = 0 ;
17288  ssize_t result;
17289 
17290  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAtomicAggregate_length",&obj0)) SWIG_fail;
17291  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAtomicAggregate, 0 | 0 );
17292  if (!SWIG_IsOK(res1)) {
17293  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAtomicAggregate_length" "', argument " "1"" of type '" "libbgp::BgpPathAttribAtomicAggregate const *""'");
17294  }
17295  arg1 = reinterpret_cast< libbgp::BgpPathAttribAtomicAggregate * >(argp1);
17296  result = ((libbgp::BgpPathAttribAtomicAggregate const *)arg1)->length();
17297  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17298  return resultobj;
17299 fail:
17300  return NULL;
17301 }
17302 
17303 
17304 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribAtomicAggregate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17305  PyObject *resultobj = 0;
17307  void *argp1 = 0 ;
17308  int res1 = 0 ;
17309  PyObject * obj0 = 0 ;
17310 
17311  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribAtomicAggregate",&obj0)) SWIG_fail;
17312  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAtomicAggregate, SWIG_POINTER_DISOWN | 0 );
17313  if (!SWIG_IsOK(res1)) {
17314  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribAtomicAggregate" "', argument " "1"" of type '" "libbgp::BgpPathAttribAtomicAggregate *""'");
17315  }
17316  arg1 = reinterpret_cast< libbgp::BgpPathAttribAtomicAggregate * >(argp1);
17317  delete arg1;
17318  resultobj = SWIG_Py_Void();
17319  return resultobj;
17320 fail:
17321  return NULL;
17322 }
17323 
17324 
17325 SWIGINTERN PyObject *BgpPathAttribAtomicAggregate_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17326  PyObject *obj;
17327  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
17328  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribAtomicAggregate, SWIG_NewClientData(obj));
17329  return SWIG_Py_Void();
17330 }
17331 
17332 SWIGINTERN PyObject *_wrap_new_BgpPathAttribAggregator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17333  PyObject *resultobj = 0;
17335  bool arg2 ;
17336  void *argp1 = 0 ;
17337  int res1 = 0 ;
17338  bool val2 ;
17339  int ecode2 = 0 ;
17340  PyObject * obj0 = 0 ;
17341  PyObject * obj1 = 0 ;
17342  libbgp::BgpPathAttribAggregator *result = 0 ;
17343 
17344  if (!PyArg_ParseTuple(args,(char *)"OO:new_BgpPathAttribAggregator",&obj0,&obj1)) SWIG_fail;
17345  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
17346  if (!SWIG_IsOK(res1)) {
17347  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribAggregator" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
17348  }
17349  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
17350  ecode2 = SWIG_AsVal_bool(obj1, &val2);
17351  if (!SWIG_IsOK(ecode2)) {
17352  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpPathAttribAggregator" "', argument " "2"" of type '" "bool""'");
17353  }
17354  arg2 = static_cast< bool >(val2);
17356  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribAggregator, SWIG_POINTER_NEW | 0 );
17357  return resultobj;
17358 fail:
17359  return NULL;
17360 }
17361 
17362 
17363 SWIGINTERN PyObject *_wrap_BgpPathAttribAggregator_aggregator_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17364  PyObject *resultobj = 0;
17366  uint32_t arg2 ;
17367  void *argp1 = 0 ;
17368  int res1 = 0 ;
17369  unsigned int val2 ;
17370  int ecode2 = 0 ;
17371  PyObject * obj0 = 0 ;
17372  PyObject * obj1 = 0 ;
17373 
17374  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribAggregator_aggregator_set",&obj0,&obj1)) SWIG_fail;
17375  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAggregator, 0 | 0 );
17376  if (!SWIG_IsOK(res1)) {
17377  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAggregator_aggregator_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribAggregator *""'");
17378  }
17379  arg1 = reinterpret_cast< libbgp::BgpPathAttribAggregator * >(argp1);
17380  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17381  if (!SWIG_IsOK(ecode2)) {
17382  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribAggregator_aggregator_set" "', argument " "2"" of type '" "uint32_t""'");
17383  }
17384  arg2 = static_cast< uint32_t >(val2);
17385  if (arg1) (arg1)->aggregator = arg2;
17386  resultobj = SWIG_Py_Void();
17387  return resultobj;
17388 fail:
17389  return NULL;
17390 }
17391 
17392 
17393 SWIGINTERN PyObject *_wrap_BgpPathAttribAggregator_aggregator_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17394  PyObject *resultobj = 0;
17396  void *argp1 = 0 ;
17397  int res1 = 0 ;
17398  PyObject * obj0 = 0 ;
17399  uint32_t result;
17400 
17401  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAggregator_aggregator_get",&obj0)) SWIG_fail;
17402  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAggregator, 0 | 0 );
17403  if (!SWIG_IsOK(res1)) {
17404  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAggregator_aggregator_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribAggregator *""'");
17405  }
17406  arg1 = reinterpret_cast< libbgp::BgpPathAttribAggregator * >(argp1);
17407  result = (uint32_t) ((arg1)->aggregator);
17408  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
17409  return resultobj;
17410 fail:
17411  return NULL;
17412 }
17413 
17414 
17415 SWIGINTERN PyObject *_wrap_BgpPathAttribAggregator_aggregator_asn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17416  PyObject *resultobj = 0;
17418  uint32_t arg2 ;
17419  void *argp1 = 0 ;
17420  int res1 = 0 ;
17421  unsigned int val2 ;
17422  int ecode2 = 0 ;
17423  PyObject * obj0 = 0 ;
17424  PyObject * obj1 = 0 ;
17425 
17426  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribAggregator_aggregator_asn_set",&obj0,&obj1)) SWIG_fail;
17427  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAggregator, 0 | 0 );
17428  if (!SWIG_IsOK(res1)) {
17429  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAggregator_aggregator_asn_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribAggregator *""'");
17430  }
17431  arg1 = reinterpret_cast< libbgp::BgpPathAttribAggregator * >(argp1);
17432  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17433  if (!SWIG_IsOK(ecode2)) {
17434  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribAggregator_aggregator_asn_set" "', argument " "2"" of type '" "uint32_t""'");
17435  }
17436  arg2 = static_cast< uint32_t >(val2);
17437  if (arg1) (arg1)->aggregator_asn = arg2;
17438  resultobj = SWIG_Py_Void();
17439  return resultobj;
17440 fail:
17441  return NULL;
17442 }
17443 
17444 
17445 SWIGINTERN PyObject *_wrap_BgpPathAttribAggregator_aggregator_asn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17446  PyObject *resultobj = 0;
17448  void *argp1 = 0 ;
17449  int res1 = 0 ;
17450  PyObject * obj0 = 0 ;
17451  uint32_t result;
17452 
17453  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAggregator_aggregator_asn_get",&obj0)) SWIG_fail;
17454  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAggregator, 0 | 0 );
17455  if (!SWIG_IsOK(res1)) {
17456  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAggregator_aggregator_asn_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribAggregator *""'");
17457  }
17458  arg1 = reinterpret_cast< libbgp::BgpPathAttribAggregator * >(argp1);
17459  result = (uint32_t) ((arg1)->aggregator_asn);
17460  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
17461  return resultobj;
17462 fail:
17463  return NULL;
17464 }
17465 
17466 
17467 SWIGINTERN PyObject *_wrap_BgpPathAttribAggregator_is_4b_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17468  PyObject *resultobj = 0;
17470  bool arg2 ;
17471  void *argp1 = 0 ;
17472  int res1 = 0 ;
17473  bool val2 ;
17474  int ecode2 = 0 ;
17475  PyObject * obj0 = 0 ;
17476  PyObject * obj1 = 0 ;
17477 
17478  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribAggregator_is_4b_set",&obj0,&obj1)) SWIG_fail;
17479  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAggregator, 0 | 0 );
17480  if (!SWIG_IsOK(res1)) {
17481  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAggregator_is_4b_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribAggregator *""'");
17482  }
17483  arg1 = reinterpret_cast< libbgp::BgpPathAttribAggregator * >(argp1);
17484  ecode2 = SWIG_AsVal_bool(obj1, &val2);
17485  if (!SWIG_IsOK(ecode2)) {
17486  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribAggregator_is_4b_set" "', argument " "2"" of type '" "bool""'");
17487  }
17488  arg2 = static_cast< bool >(val2);
17489  if (arg1) (arg1)->is_4b = arg2;
17490  resultobj = SWIG_Py_Void();
17491  return resultobj;
17492 fail:
17493  return NULL;
17494 }
17495 
17496 
17497 SWIGINTERN PyObject *_wrap_BgpPathAttribAggregator_is_4b_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17498  PyObject *resultobj = 0;
17500  void *argp1 = 0 ;
17501  int res1 = 0 ;
17502  PyObject * obj0 = 0 ;
17503  bool result;
17504 
17505  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAggregator_is_4b_get",&obj0)) SWIG_fail;
17506  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAggregator, 0 | 0 );
17507  if (!SWIG_IsOK(res1)) {
17508  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAggregator_is_4b_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribAggregator *""'");
17509  }
17510  arg1 = reinterpret_cast< libbgp::BgpPathAttribAggregator * >(argp1);
17511  result = (bool) ((arg1)->is_4b);
17512  resultobj = SWIG_From_bool(static_cast< bool >(result));
17513  return resultobj;
17514 fail:
17515  return NULL;
17516 }
17517 
17518 
17519 SWIGINTERN PyObject *_wrap_BgpPathAttribAggregator_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17520  PyObject *resultobj = 0;
17522  void *argp1 = 0 ;
17523  int res1 = 0 ;
17524  PyObject * obj0 = 0 ;
17525  libbgp::BgpPathAttrib *result = 0 ;
17526 
17527  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAggregator_clone",&obj0)) SWIG_fail;
17528  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAggregator, 0 | 0 );
17529  if (!SWIG_IsOK(res1)) {
17530  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAggregator_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttribAggregator const *""'");
17531  }
17532  arg1 = reinterpret_cast< libbgp::BgpPathAttribAggregator * >(argp1);
17533  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttribAggregator const *)arg1)->clone();
17534  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
17535  return resultobj;
17536 fail:
17537  return NULL;
17538 }
17539 
17540 
17541 SWIGINTERN PyObject *_wrap_BgpPathAttribAggregator_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17542  PyObject *resultobj = 0;
17544  uint8_t *arg2 = (uint8_t *) 0 ;
17545  size_t arg3 ;
17546  void *argp1 = 0 ;
17547  int res1 = 0 ;
17548  void *argp2 = 0 ;
17549  int res2 = 0 ;
17550  size_t val3 ;
17551  int ecode3 = 0 ;
17552  PyObject * obj0 = 0 ;
17553  PyObject * obj1 = 0 ;
17554  PyObject * obj2 = 0 ;
17555  ssize_t result;
17556 
17557  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribAggregator_parse",&obj0,&obj1,&obj2)) SWIG_fail;
17558  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAggregator, 0 | 0 );
17559  if (!SWIG_IsOK(res1)) {
17560  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAggregator_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttribAggregator *""'");
17561  }
17562  arg1 = reinterpret_cast< libbgp::BgpPathAttribAggregator * >(argp1);
17563  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
17564  if (!SWIG_IsOK(res2)) {
17565  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribAggregator_parse" "', argument " "2"" of type '" "uint8_t const *""'");
17566  }
17567  arg2 = reinterpret_cast< uint8_t * >(argp2);
17568  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
17569  if (!SWIG_IsOK(ecode3)) {
17570  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribAggregator_parse" "', argument " "3"" of type '" "size_t""'");
17571  }
17572  arg3 = static_cast< size_t >(val3);
17573  result = (arg1)->parse((uint8_t const *)arg2,arg3);
17574  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17575  return resultobj;
17576 fail:
17577  return NULL;
17578 }
17579 
17580 
17581 SWIGINTERN PyObject *_wrap_BgpPathAttribAggregator_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17582  PyObject *resultobj = 0;
17584  uint8_t *arg2 = (uint8_t *) 0 ;
17585  size_t arg3 ;
17586  void *argp1 = 0 ;
17587  int res1 = 0 ;
17588  void *argp2 = 0 ;
17589  int res2 = 0 ;
17590  size_t val3 ;
17591  int ecode3 = 0 ;
17592  PyObject * obj0 = 0 ;
17593  PyObject * obj1 = 0 ;
17594  PyObject * obj2 = 0 ;
17595  ssize_t result;
17596 
17597  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribAggregator_write",&obj0,&obj1,&obj2)) SWIG_fail;
17598  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAggregator, 0 | 0 );
17599  if (!SWIG_IsOK(res1)) {
17600  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAggregator_write" "', argument " "1"" of type '" "libbgp::BgpPathAttribAggregator const *""'");
17601  }
17602  arg1 = reinterpret_cast< libbgp::BgpPathAttribAggregator * >(argp1);
17603  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
17604  if (!SWIG_IsOK(res2)) {
17605  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribAggregator_write" "', argument " "2"" of type '" "uint8_t *""'");
17606  }
17607  arg2 = reinterpret_cast< uint8_t * >(argp2);
17608  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
17609  if (!SWIG_IsOK(ecode3)) {
17610  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribAggregator_write" "', argument " "3"" of type '" "size_t""'");
17611  }
17612  arg3 = static_cast< size_t >(val3);
17613  result = ((libbgp::BgpPathAttribAggregator const *)arg1)->write(arg2,arg3);
17614  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17615  return resultobj;
17616 fail:
17617  return NULL;
17618 }
17619 
17620 
17621 SWIGINTERN PyObject *_wrap_BgpPathAttribAggregator_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17622  PyObject *resultobj = 0;
17624  size_t arg2 ;
17625  uint8_t **arg3 = (uint8_t **) 0 ;
17626  size_t *arg4 = (size_t *) 0 ;
17627  void *argp1 = 0 ;
17628  int res1 = 0 ;
17629  size_t val2 ;
17630  int ecode2 = 0 ;
17631  void *argp3 = 0 ;
17632  int res3 = 0 ;
17633  void *argp4 = 0 ;
17634  int res4 = 0 ;
17635  PyObject * obj0 = 0 ;
17636  PyObject * obj1 = 0 ;
17637  PyObject * obj2 = 0 ;
17638  PyObject * obj3 = 0 ;
17639  ssize_t result;
17640 
17641  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttribAggregator_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17642  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAggregator, 0 | 0 );
17643  if (!SWIG_IsOK(res1)) {
17644  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAggregator_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttribAggregator const *""'");
17645  }
17646  arg1 = reinterpret_cast< libbgp::BgpPathAttribAggregator * >(argp1);
17647  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17648  if (!SWIG_IsOK(ecode2)) {
17649  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribAggregator_doPrint" "', argument " "2"" of type '" "size_t""'");
17650  }
17651  arg2 = static_cast< size_t >(val2);
17652  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
17653  if (!SWIG_IsOK(res3)) {
17654  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttribAggregator_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
17655  }
17656  arg3 = reinterpret_cast< uint8_t ** >(argp3);
17657  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
17658  if (!SWIG_IsOK(res4)) {
17659  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttribAggregator_doPrint" "', argument " "4"" of type '" "size_t *""'");
17660  }
17661  arg4 = reinterpret_cast< size_t * >(argp4);
17662  result = ((libbgp::BgpPathAttribAggregator const *)arg1)->doPrint(arg2,arg3,arg4);
17663  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17664  return resultobj;
17665 fail:
17666  return NULL;
17667 }
17668 
17669 
17670 SWIGINTERN PyObject *_wrap_BgpPathAttribAggregator_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17671  PyObject *resultobj = 0;
17673  void *argp1 = 0 ;
17674  int res1 = 0 ;
17675  PyObject * obj0 = 0 ;
17676  ssize_t result;
17677 
17678  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAggregator_length",&obj0)) SWIG_fail;
17679  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAggregator, 0 | 0 );
17680  if (!SWIG_IsOK(res1)) {
17681  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAggregator_length" "', argument " "1"" of type '" "libbgp::BgpPathAttribAggregator const *""'");
17682  }
17683  arg1 = reinterpret_cast< libbgp::BgpPathAttribAggregator * >(argp1);
17684  result = ((libbgp::BgpPathAttribAggregator const *)arg1)->length();
17685  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17686  return resultobj;
17687 fail:
17688  return NULL;
17689 }
17690 
17691 
17692 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribAggregator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17693  PyObject *resultobj = 0;
17695  void *argp1 = 0 ;
17696  int res1 = 0 ;
17697  PyObject * obj0 = 0 ;
17698 
17699  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribAggregator",&obj0)) SWIG_fail;
17700  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAggregator, SWIG_POINTER_DISOWN | 0 );
17701  if (!SWIG_IsOK(res1)) {
17702  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribAggregator" "', argument " "1"" of type '" "libbgp::BgpPathAttribAggregator *""'");
17703  }
17704  arg1 = reinterpret_cast< libbgp::BgpPathAttribAggregator * >(argp1);
17705  delete arg1;
17706  resultobj = SWIG_Py_Void();
17707  return resultobj;
17708 fail:
17709  return NULL;
17710 }
17711 
17712 
17713 SWIGINTERN PyObject *BgpPathAttribAggregator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17714  PyObject *obj;
17715  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
17716  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribAggregator, SWIG_NewClientData(obj));
17717  return SWIG_Py_Void();
17718 }
17719 
17720 SWIGINTERN PyObject *_wrap_new_BgpPathAttribAs4Path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17721  PyObject *resultobj = 0;
17723  void *argp1 = 0 ;
17724  int res1 = 0 ;
17725  PyObject * obj0 = 0 ;
17726  libbgp::BgpPathAttribAs4Path *result = 0 ;
17727 
17728  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpPathAttribAs4Path",&obj0)) SWIG_fail;
17729  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
17730  if (!SWIG_IsOK(res1)) {
17731  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribAs4Path" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
17732  }
17733  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
17735  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribAs4Path, SWIG_POINTER_NEW | 0 );
17736  return resultobj;
17737 fail:
17738  return NULL;
17739 }
17740 
17741 
17742 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Path_as4_paths_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17743  PyObject *resultobj = 0;
17745  std::vector< libbgp::BgpAsPathSegment > *arg2 = (std::vector< libbgp::BgpAsPathSegment > *) 0 ;
17746  void *argp1 = 0 ;
17747  int res1 = 0 ;
17748  void *argp2 = 0 ;
17749  int res2 = 0 ;
17750  PyObject * obj0 = 0 ;
17751  PyObject * obj1 = 0 ;
17752 
17753  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribAs4Path_as4_paths_set",&obj0,&obj1)) SWIG_fail;
17754  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Path, 0 | 0 );
17755  if (!SWIG_IsOK(res1)) {
17756  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Path_as4_paths_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Path *""'");
17757  }
17758  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Path * >(argp1);
17759  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_libbgp__BgpAsPathSegment_t, 0 | 0 );
17760  if (!SWIG_IsOK(res2)) {
17761  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribAs4Path_as4_paths_set" "', argument " "2"" of type '" "std::vector< libbgp::BgpAsPathSegment > *""'");
17762  }
17763  arg2 = reinterpret_cast< std::vector< libbgp::BgpAsPathSegment > * >(argp2);
17764  if (arg1) (arg1)->as4_paths = *arg2;
17765  resultobj = SWIG_Py_Void();
17766  return resultobj;
17767 fail:
17768  return NULL;
17769 }
17770 
17771 
17772 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Path_as4_paths_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17773  PyObject *resultobj = 0;
17775  void *argp1 = 0 ;
17776  int res1 = 0 ;
17777  PyObject * obj0 = 0 ;
17778  std::vector< libbgp::BgpAsPathSegment > *result = 0 ;
17779 
17780  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAs4Path_as4_paths_get",&obj0)) SWIG_fail;
17781  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Path, 0 | 0 );
17782  if (!SWIG_IsOK(res1)) {
17783  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Path_as4_paths_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Path *""'");
17784  }
17785  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Path * >(argp1);
17786  result = (std::vector< libbgp::BgpAsPathSegment > *)& ((arg1)->as4_paths);
17787  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_libbgp__BgpAsPathSegment_t, 0 | 0 );
17788  return resultobj;
17789 fail:
17790  return NULL;
17791 }
17792 
17793 
17794 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Path_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17795  PyObject *resultobj = 0;
17797  uint32_t arg2 ;
17798  void *argp1 = 0 ;
17799  int res1 = 0 ;
17800  unsigned int val2 ;
17801  int ecode2 = 0 ;
17802  PyObject * obj0 = 0 ;
17803  PyObject * obj1 = 0 ;
17804  bool result;
17805 
17806  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribAs4Path_prepend",&obj0,&obj1)) SWIG_fail;
17807  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Path, 0 | 0 );
17808  if (!SWIG_IsOK(res1)) {
17809  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Path_prepend" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Path *""'");
17810  }
17811  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Path * >(argp1);
17812  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17813  if (!SWIG_IsOK(ecode2)) {
17814  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribAs4Path_prepend" "', argument " "2"" of type '" "uint32_t""'");
17815  }
17816  arg2 = static_cast< uint32_t >(val2);
17817  result = (bool)(arg1)->prepend(arg2);
17818  resultobj = SWIG_From_bool(static_cast< bool >(result));
17819  return resultobj;
17820 fail:
17821  return NULL;
17822 }
17823 
17824 
17825 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Path_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17826  PyObject *resultobj = 0;
17828  void *argp1 = 0 ;
17829  int res1 = 0 ;
17830  PyObject * obj0 = 0 ;
17831  libbgp::BgpPathAttrib *result = 0 ;
17832 
17833  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAs4Path_clone",&obj0)) SWIG_fail;
17834  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Path, 0 | 0 );
17835  if (!SWIG_IsOK(res1)) {
17836  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Path_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Path const *""'");
17837  }
17838  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Path * >(argp1);
17839  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttribAs4Path const *)arg1)->clone();
17840  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
17841  return resultobj;
17842 fail:
17843  return NULL;
17844 }
17845 
17846 
17847 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Path_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17848  PyObject *resultobj = 0;
17850  uint8_t *arg2 = (uint8_t *) 0 ;
17851  size_t arg3 ;
17852  void *argp1 = 0 ;
17853  int res1 = 0 ;
17854  void *argp2 = 0 ;
17855  int res2 = 0 ;
17856  size_t val3 ;
17857  int ecode3 = 0 ;
17858  PyObject * obj0 = 0 ;
17859  PyObject * obj1 = 0 ;
17860  PyObject * obj2 = 0 ;
17861  ssize_t result;
17862 
17863  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribAs4Path_parse",&obj0,&obj1,&obj2)) SWIG_fail;
17864  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Path, 0 | 0 );
17865  if (!SWIG_IsOK(res1)) {
17866  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Path_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Path *""'");
17867  }
17868  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Path * >(argp1);
17869  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
17870  if (!SWIG_IsOK(res2)) {
17871  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribAs4Path_parse" "', argument " "2"" of type '" "uint8_t const *""'");
17872  }
17873  arg2 = reinterpret_cast< uint8_t * >(argp2);
17874  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
17875  if (!SWIG_IsOK(ecode3)) {
17876  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribAs4Path_parse" "', argument " "3"" of type '" "size_t""'");
17877  }
17878  arg3 = static_cast< size_t >(val3);
17879  result = (arg1)->parse((uint8_t const *)arg2,arg3);
17880  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17881  return resultobj;
17882 fail:
17883  return NULL;
17884 }
17885 
17886 
17887 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Path_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17888  PyObject *resultobj = 0;
17890  uint8_t *arg2 = (uint8_t *) 0 ;
17891  size_t arg3 ;
17892  void *argp1 = 0 ;
17893  int res1 = 0 ;
17894  void *argp2 = 0 ;
17895  int res2 = 0 ;
17896  size_t val3 ;
17897  int ecode3 = 0 ;
17898  PyObject * obj0 = 0 ;
17899  PyObject * obj1 = 0 ;
17900  PyObject * obj2 = 0 ;
17901  ssize_t result;
17902 
17903  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribAs4Path_write",&obj0,&obj1,&obj2)) SWIG_fail;
17904  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Path, 0 | 0 );
17905  if (!SWIG_IsOK(res1)) {
17906  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Path_write" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Path const *""'");
17907  }
17908  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Path * >(argp1);
17909  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
17910  if (!SWIG_IsOK(res2)) {
17911  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribAs4Path_write" "', argument " "2"" of type '" "uint8_t *""'");
17912  }
17913  arg2 = reinterpret_cast< uint8_t * >(argp2);
17914  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
17915  if (!SWIG_IsOK(ecode3)) {
17916  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribAs4Path_write" "', argument " "3"" of type '" "size_t""'");
17917  }
17918  arg3 = static_cast< size_t >(val3);
17919  result = ((libbgp::BgpPathAttribAs4Path const *)arg1)->write(arg2,arg3);
17920  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17921  return resultobj;
17922 fail:
17923  return NULL;
17924 }
17925 
17926 
17927 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Path_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17928  PyObject *resultobj = 0;
17930  size_t arg2 ;
17931  uint8_t **arg3 = (uint8_t **) 0 ;
17932  size_t *arg4 = (size_t *) 0 ;
17933  void *argp1 = 0 ;
17934  int res1 = 0 ;
17935  size_t val2 ;
17936  int ecode2 = 0 ;
17937  void *argp3 = 0 ;
17938  int res3 = 0 ;
17939  void *argp4 = 0 ;
17940  int res4 = 0 ;
17941  PyObject * obj0 = 0 ;
17942  PyObject * obj1 = 0 ;
17943  PyObject * obj2 = 0 ;
17944  PyObject * obj3 = 0 ;
17945  ssize_t result;
17946 
17947  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttribAs4Path_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17948  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Path, 0 | 0 );
17949  if (!SWIG_IsOK(res1)) {
17950  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Path_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Path const *""'");
17951  }
17952  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Path * >(argp1);
17953  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
17954  if (!SWIG_IsOK(ecode2)) {
17955  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribAs4Path_doPrint" "', argument " "2"" of type '" "size_t""'");
17956  }
17957  arg2 = static_cast< size_t >(val2);
17958  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
17959  if (!SWIG_IsOK(res3)) {
17960  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttribAs4Path_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
17961  }
17962  arg3 = reinterpret_cast< uint8_t ** >(argp3);
17963  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
17964  if (!SWIG_IsOK(res4)) {
17965  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttribAs4Path_doPrint" "', argument " "4"" of type '" "size_t *""'");
17966  }
17967  arg4 = reinterpret_cast< size_t * >(argp4);
17968  result = ((libbgp::BgpPathAttribAs4Path const *)arg1)->doPrint(arg2,arg3,arg4);
17969  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17970  return resultobj;
17971 fail:
17972  return NULL;
17973 }
17974 
17975 
17976 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Path_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17977  PyObject *resultobj = 0;
17979  void *argp1 = 0 ;
17980  int res1 = 0 ;
17981  PyObject * obj0 = 0 ;
17982  ssize_t result;
17983 
17984  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAs4Path_length",&obj0)) SWIG_fail;
17985  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Path, 0 | 0 );
17986  if (!SWIG_IsOK(res1)) {
17987  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Path_length" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Path const *""'");
17988  }
17989  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Path * >(argp1);
17990  result = ((libbgp::BgpPathAttribAs4Path const *)arg1)->length();
17991  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
17992  return resultobj;
17993 fail:
17994  return NULL;
17995 }
17996 
17997 
17998 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribAs4Path(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17999  PyObject *resultobj = 0;
18001  void *argp1 = 0 ;
18002  int res1 = 0 ;
18003  PyObject * obj0 = 0 ;
18004 
18005  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribAs4Path",&obj0)) SWIG_fail;
18006  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Path, SWIG_POINTER_DISOWN | 0 );
18007  if (!SWIG_IsOK(res1)) {
18008  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribAs4Path" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Path *""'");
18009  }
18010  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Path * >(argp1);
18011  delete arg1;
18012  resultobj = SWIG_Py_Void();
18013  return resultobj;
18014 fail:
18015  return NULL;
18016 }
18017 
18018 
18019 SWIGINTERN PyObject *BgpPathAttribAs4Path_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18020  PyObject *obj;
18021  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
18022  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribAs4Path, SWIG_NewClientData(obj));
18023  return SWIG_Py_Void();
18024 }
18025 
18026 SWIGINTERN PyObject *_wrap_new_BgpPathAttribAs4Aggregator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18027  PyObject *resultobj = 0;
18029  void *argp1 = 0 ;
18030  int res1 = 0 ;
18031  PyObject * obj0 = 0 ;
18033 
18034  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpPathAttribAs4Aggregator",&obj0)) SWIG_fail;
18035  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
18036  if (!SWIG_IsOK(res1)) {
18037  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribAs4Aggregator" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
18038  }
18039  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
18041  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribAs4Aggregator, SWIG_POINTER_NEW | 0 );
18042  return resultobj;
18043 fail:
18044  return NULL;
18045 }
18046 
18047 
18048 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Aggregator_aggregator_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18049  PyObject *resultobj = 0;
18051  uint32_t arg2 ;
18052  void *argp1 = 0 ;
18053  int res1 = 0 ;
18054  unsigned int val2 ;
18055  int ecode2 = 0 ;
18056  PyObject * obj0 = 0 ;
18057  PyObject * obj1 = 0 ;
18058 
18059  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribAs4Aggregator_aggregator_set",&obj0,&obj1)) SWIG_fail;
18060  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Aggregator, 0 | 0 );
18061  if (!SWIG_IsOK(res1)) {
18062  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Aggregator_aggregator_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Aggregator *""'");
18063  }
18064  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Aggregator * >(argp1);
18065  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
18066  if (!SWIG_IsOK(ecode2)) {
18067  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribAs4Aggregator_aggregator_set" "', argument " "2"" of type '" "uint32_t""'");
18068  }
18069  arg2 = static_cast< uint32_t >(val2);
18070  if (arg1) (arg1)->aggregator = arg2;
18071  resultobj = SWIG_Py_Void();
18072  return resultobj;
18073 fail:
18074  return NULL;
18075 }
18076 
18077 
18078 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Aggregator_aggregator_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18079  PyObject *resultobj = 0;
18081  void *argp1 = 0 ;
18082  int res1 = 0 ;
18083  PyObject * obj0 = 0 ;
18084  uint32_t result;
18085 
18086  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAs4Aggregator_aggregator_get",&obj0)) SWIG_fail;
18087  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Aggregator, 0 | 0 );
18088  if (!SWIG_IsOK(res1)) {
18089  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Aggregator_aggregator_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Aggregator *""'");
18090  }
18091  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Aggregator * >(argp1);
18092  result = (uint32_t) ((arg1)->aggregator);
18093  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
18094  return resultobj;
18095 fail:
18096  return NULL;
18097 }
18098 
18099 
18100 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Aggregator_aggregator_asn4_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18101  PyObject *resultobj = 0;
18103  uint32_t arg2 ;
18104  void *argp1 = 0 ;
18105  int res1 = 0 ;
18106  unsigned int val2 ;
18107  int ecode2 = 0 ;
18108  PyObject * obj0 = 0 ;
18109  PyObject * obj1 = 0 ;
18110 
18111  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribAs4Aggregator_aggregator_asn4_set",&obj0,&obj1)) SWIG_fail;
18112  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Aggregator, 0 | 0 );
18113  if (!SWIG_IsOK(res1)) {
18114  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Aggregator_aggregator_asn4_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Aggregator *""'");
18115  }
18116  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Aggregator * >(argp1);
18117  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
18118  if (!SWIG_IsOK(ecode2)) {
18119  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribAs4Aggregator_aggregator_asn4_set" "', argument " "2"" of type '" "uint32_t""'");
18120  }
18121  arg2 = static_cast< uint32_t >(val2);
18122  if (arg1) (arg1)->aggregator_asn4 = arg2;
18123  resultobj = SWIG_Py_Void();
18124  return resultobj;
18125 fail:
18126  return NULL;
18127 }
18128 
18129 
18130 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Aggregator_aggregator_asn4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18131  PyObject *resultobj = 0;
18133  void *argp1 = 0 ;
18134  int res1 = 0 ;
18135  PyObject * obj0 = 0 ;
18136  uint32_t result;
18137 
18138  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAs4Aggregator_aggregator_asn4_get",&obj0)) SWIG_fail;
18139  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Aggregator, 0 | 0 );
18140  if (!SWIG_IsOK(res1)) {
18141  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Aggregator_aggregator_asn4_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Aggregator *""'");
18142  }
18143  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Aggregator * >(argp1);
18144  result = (uint32_t) ((arg1)->aggregator_asn4);
18145  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
18146  return resultobj;
18147 fail:
18148  return NULL;
18149 }
18150 
18151 
18152 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Aggregator_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18153  PyObject *resultobj = 0;
18155  void *argp1 = 0 ;
18156  int res1 = 0 ;
18157  PyObject * obj0 = 0 ;
18158  libbgp::BgpPathAttrib *result = 0 ;
18159 
18160  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAs4Aggregator_clone",&obj0)) SWIG_fail;
18161  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Aggregator, 0 | 0 );
18162  if (!SWIG_IsOK(res1)) {
18163  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Aggregator_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Aggregator const *""'");
18164  }
18165  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Aggregator * >(argp1);
18166  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttribAs4Aggregator const *)arg1)->clone();
18167  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
18168  return resultobj;
18169 fail:
18170  return NULL;
18171 }
18172 
18173 
18174 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Aggregator_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18175  PyObject *resultobj = 0;
18177  uint8_t *arg2 = (uint8_t *) 0 ;
18178  size_t arg3 ;
18179  void *argp1 = 0 ;
18180  int res1 = 0 ;
18181  void *argp2 = 0 ;
18182  int res2 = 0 ;
18183  size_t val3 ;
18184  int ecode3 = 0 ;
18185  PyObject * obj0 = 0 ;
18186  PyObject * obj1 = 0 ;
18187  PyObject * obj2 = 0 ;
18188  ssize_t result;
18189 
18190  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribAs4Aggregator_parse",&obj0,&obj1,&obj2)) SWIG_fail;
18191  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Aggregator, 0 | 0 );
18192  if (!SWIG_IsOK(res1)) {
18193  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Aggregator_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Aggregator *""'");
18194  }
18195  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Aggregator * >(argp1);
18196  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
18197  if (!SWIG_IsOK(res2)) {
18198  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribAs4Aggregator_parse" "', argument " "2"" of type '" "uint8_t const *""'");
18199  }
18200  arg2 = reinterpret_cast< uint8_t * >(argp2);
18201  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
18202  if (!SWIG_IsOK(ecode3)) {
18203  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribAs4Aggregator_parse" "', argument " "3"" of type '" "size_t""'");
18204  }
18205  arg3 = static_cast< size_t >(val3);
18206  result = (arg1)->parse((uint8_t const *)arg2,arg3);
18207  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
18208  return resultobj;
18209 fail:
18210  return NULL;
18211 }
18212 
18213 
18214 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Aggregator_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18215  PyObject *resultobj = 0;
18217  uint8_t *arg2 = (uint8_t *) 0 ;
18218  size_t arg3 ;
18219  void *argp1 = 0 ;
18220  int res1 = 0 ;
18221  void *argp2 = 0 ;
18222  int res2 = 0 ;
18223  size_t val3 ;
18224  int ecode3 = 0 ;
18225  PyObject * obj0 = 0 ;
18226  PyObject * obj1 = 0 ;
18227  PyObject * obj2 = 0 ;
18228  ssize_t result;
18229 
18230  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribAs4Aggregator_write",&obj0,&obj1,&obj2)) SWIG_fail;
18231  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Aggregator, 0 | 0 );
18232  if (!SWIG_IsOK(res1)) {
18233  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Aggregator_write" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Aggregator const *""'");
18234  }
18235  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Aggregator * >(argp1);
18236  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
18237  if (!SWIG_IsOK(res2)) {
18238  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribAs4Aggregator_write" "', argument " "2"" of type '" "uint8_t *""'");
18239  }
18240  arg2 = reinterpret_cast< uint8_t * >(argp2);
18241  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
18242  if (!SWIG_IsOK(ecode3)) {
18243  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribAs4Aggregator_write" "', argument " "3"" of type '" "size_t""'");
18244  }
18245  arg3 = static_cast< size_t >(val3);
18246  result = ((libbgp::BgpPathAttribAs4Aggregator const *)arg1)->write(arg2,arg3);
18247  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
18248  return resultobj;
18249 fail:
18250  return NULL;
18251 }
18252 
18253 
18254 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Aggregator_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18255  PyObject *resultobj = 0;
18257  size_t arg2 ;
18258  uint8_t **arg3 = (uint8_t **) 0 ;
18259  size_t *arg4 = (size_t *) 0 ;
18260  void *argp1 = 0 ;
18261  int res1 = 0 ;
18262  size_t val2 ;
18263  int ecode2 = 0 ;
18264  void *argp3 = 0 ;
18265  int res3 = 0 ;
18266  void *argp4 = 0 ;
18267  int res4 = 0 ;
18268  PyObject * obj0 = 0 ;
18269  PyObject * obj1 = 0 ;
18270  PyObject * obj2 = 0 ;
18271  PyObject * obj3 = 0 ;
18272  ssize_t result;
18273 
18274  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttribAs4Aggregator_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18275  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Aggregator, 0 | 0 );
18276  if (!SWIG_IsOK(res1)) {
18277  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Aggregator_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Aggregator const *""'");
18278  }
18279  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Aggregator * >(argp1);
18280  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
18281  if (!SWIG_IsOK(ecode2)) {
18282  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribAs4Aggregator_doPrint" "', argument " "2"" of type '" "size_t""'");
18283  }
18284  arg2 = static_cast< size_t >(val2);
18285  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
18286  if (!SWIG_IsOK(res3)) {
18287  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttribAs4Aggregator_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
18288  }
18289  arg3 = reinterpret_cast< uint8_t ** >(argp3);
18290  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
18291  if (!SWIG_IsOK(res4)) {
18292  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttribAs4Aggregator_doPrint" "', argument " "4"" of type '" "size_t *""'");
18293  }
18294  arg4 = reinterpret_cast< size_t * >(argp4);
18295  result = ((libbgp::BgpPathAttribAs4Aggregator const *)arg1)->doPrint(arg2,arg3,arg4);
18296  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
18297  return resultobj;
18298 fail:
18299  return NULL;
18300 }
18301 
18302 
18303 SWIGINTERN PyObject *_wrap_BgpPathAttribAs4Aggregator_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18304  PyObject *resultobj = 0;
18306  void *argp1 = 0 ;
18307  int res1 = 0 ;
18308  PyObject * obj0 = 0 ;
18309  ssize_t result;
18310 
18311  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribAs4Aggregator_length",&obj0)) SWIG_fail;
18312  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Aggregator, 0 | 0 );
18313  if (!SWIG_IsOK(res1)) {
18314  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribAs4Aggregator_length" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Aggregator const *""'");
18315  }
18316  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Aggregator * >(argp1);
18317  result = ((libbgp::BgpPathAttribAs4Aggregator const *)arg1)->length();
18318  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
18319  return resultobj;
18320 fail:
18321  return NULL;
18322 }
18323 
18324 
18325 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribAs4Aggregator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18326  PyObject *resultobj = 0;
18328  void *argp1 = 0 ;
18329  int res1 = 0 ;
18330  PyObject * obj0 = 0 ;
18331 
18332  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribAs4Aggregator",&obj0)) SWIG_fail;
18333  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribAs4Aggregator, SWIG_POINTER_DISOWN | 0 );
18334  if (!SWIG_IsOK(res1)) {
18335  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribAs4Aggregator" "', argument " "1"" of type '" "libbgp::BgpPathAttribAs4Aggregator *""'");
18336  }
18337  arg1 = reinterpret_cast< libbgp::BgpPathAttribAs4Aggregator * >(argp1);
18338  delete arg1;
18339  resultobj = SWIG_Py_Void();
18340  return resultobj;
18341 fail:
18342  return NULL;
18343 }
18344 
18345 
18346 SWIGINTERN PyObject *BgpPathAttribAs4Aggregator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18347  PyObject *obj;
18348  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
18349  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribAs4Aggregator, SWIG_NewClientData(obj));
18350  return SWIG_Py_Void();
18351 }
18352 
18353 SWIGINTERN PyObject *_wrap_new_BgpPathAttribCommunity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18354  PyObject *resultobj = 0;
18356  void *argp1 = 0 ;
18357  int res1 = 0 ;
18358  PyObject * obj0 = 0 ;
18359  libbgp::BgpPathAttribCommunity *result = 0 ;
18360 
18361  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpPathAttribCommunity",&obj0)) SWIG_fail;
18362  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
18363  if (!SWIG_IsOK(res1)) {
18364  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribCommunity" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
18365  }
18366  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
18368  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribCommunity, SWIG_POINTER_NEW | 0 );
18369  return resultobj;
18370 fail:
18371  return NULL;
18372 }
18373 
18374 
18375 SWIGINTERN PyObject *_wrap_BgpPathAttribCommunity_communites_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18376  PyObject *resultobj = 0;
18378  std::vector< uint32_t > arg2 ;
18379  void *argp1 = 0 ;
18380  int res1 = 0 ;
18381  void *argp2 ;
18382  int res2 = 0 ;
18383  PyObject * obj0 = 0 ;
18384  PyObject * obj1 = 0 ;
18385 
18386  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribCommunity_communites_set",&obj0,&obj1)) SWIG_fail;
18387  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribCommunity, 0 | 0 );
18388  if (!SWIG_IsOK(res1)) {
18389  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribCommunity_communites_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribCommunity *""'");
18390  }
18391  arg1 = reinterpret_cast< libbgp::BgpPathAttribCommunity * >(argp1);
18392  {
18393  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 | 0);
18394  if (!SWIG_IsOK(res2)) {
18395  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribCommunity_communites_set" "', argument " "2"" of type '" "std::vector< uint32_t >""'");
18396  }
18397  if (!argp2) {
18398  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpPathAttribCommunity_communites_set" "', argument " "2"" of type '" "std::vector< uint32_t >""'");
18399  } else {
18400  std::vector< uint32_t > * temp = reinterpret_cast< std::vector< uint32_t > * >(argp2);
18401  arg2 = *temp;
18402  if (SWIG_IsNewObj(res2)) delete temp;
18403  }
18404  }
18405  if (arg1) (arg1)->communites = arg2;
18406  resultobj = SWIG_Py_Void();
18407  return resultobj;
18408 fail:
18409  return NULL;
18410 }
18411 
18412 
18413 SWIGINTERN PyObject *_wrap_BgpPathAttribCommunity_communites_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18414  PyObject *resultobj = 0;
18416  void *argp1 = 0 ;
18417  int res1 = 0 ;
18418  PyObject * obj0 = 0 ;
18419  std::vector< uint32_t > result;
18420 
18421  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribCommunity_communites_get",&obj0)) SWIG_fail;
18422  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribCommunity, 0 | 0 );
18423  if (!SWIG_IsOK(res1)) {
18424  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribCommunity_communites_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribCommunity *""'");
18425  }
18426  arg1 = reinterpret_cast< libbgp::BgpPathAttribCommunity * >(argp1);
18427  result = ((arg1)->communites);
18428  resultobj = SWIG_NewPointerObj((new std::vector< uint32_t >(static_cast< const std::vector< uint32_t >& >(result))), SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_POINTER_OWN | 0 );
18429  return resultobj;
18430 fail:
18431  return NULL;
18432 }
18433 
18434 
18435 SWIGINTERN PyObject *_wrap_BgpPathAttribCommunity_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18436  PyObject *resultobj = 0;
18438  void *argp1 = 0 ;
18439  int res1 = 0 ;
18440  PyObject * obj0 = 0 ;
18441  libbgp::BgpPathAttrib *result = 0 ;
18442 
18443  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribCommunity_clone",&obj0)) SWIG_fail;
18444  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribCommunity, 0 | 0 );
18445  if (!SWIG_IsOK(res1)) {
18446  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribCommunity_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttribCommunity const *""'");
18447  }
18448  arg1 = reinterpret_cast< libbgp::BgpPathAttribCommunity * >(argp1);
18449  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttribCommunity const *)arg1)->clone();
18450  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
18451  return resultobj;
18452 fail:
18453  return NULL;
18454 }
18455 
18456 
18457 SWIGINTERN PyObject *_wrap_BgpPathAttribCommunity_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18458  PyObject *resultobj = 0;
18460  uint8_t *arg2 = (uint8_t *) 0 ;
18461  size_t arg3 ;
18462  void *argp1 = 0 ;
18463  int res1 = 0 ;
18464  void *argp2 = 0 ;
18465  int res2 = 0 ;
18466  size_t val3 ;
18467  int ecode3 = 0 ;
18468  PyObject * obj0 = 0 ;
18469  PyObject * obj1 = 0 ;
18470  PyObject * obj2 = 0 ;
18471  ssize_t result;
18472 
18473  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribCommunity_parse",&obj0,&obj1,&obj2)) SWIG_fail;
18474  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribCommunity, 0 | 0 );
18475  if (!SWIG_IsOK(res1)) {
18476  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribCommunity_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttribCommunity *""'");
18477  }
18478  arg1 = reinterpret_cast< libbgp::BgpPathAttribCommunity * >(argp1);
18479  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
18480  if (!SWIG_IsOK(res2)) {
18481  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribCommunity_parse" "', argument " "2"" of type '" "uint8_t const *""'");
18482  }
18483  arg2 = reinterpret_cast< uint8_t * >(argp2);
18484  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
18485  if (!SWIG_IsOK(ecode3)) {
18486  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribCommunity_parse" "', argument " "3"" of type '" "size_t""'");
18487  }
18488  arg3 = static_cast< size_t >(val3);
18489  result = (arg1)->parse((uint8_t const *)arg2,arg3);
18490  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
18491  return resultobj;
18492 fail:
18493  return NULL;
18494 }
18495 
18496 
18497 SWIGINTERN PyObject *_wrap_BgpPathAttribCommunity_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18498  PyObject *resultobj = 0;
18500  uint8_t *arg2 = (uint8_t *) 0 ;
18501  size_t arg3 ;
18502  void *argp1 = 0 ;
18503  int res1 = 0 ;
18504  void *argp2 = 0 ;
18505  int res2 = 0 ;
18506  size_t val3 ;
18507  int ecode3 = 0 ;
18508  PyObject * obj0 = 0 ;
18509  PyObject * obj1 = 0 ;
18510  PyObject * obj2 = 0 ;
18511  ssize_t result;
18512 
18513  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribCommunity_write",&obj0,&obj1,&obj2)) SWIG_fail;
18514  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribCommunity, 0 | 0 );
18515  if (!SWIG_IsOK(res1)) {
18516  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribCommunity_write" "', argument " "1"" of type '" "libbgp::BgpPathAttribCommunity const *""'");
18517  }
18518  arg1 = reinterpret_cast< libbgp::BgpPathAttribCommunity * >(argp1);
18519  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
18520  if (!SWIG_IsOK(res2)) {
18521  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribCommunity_write" "', argument " "2"" of type '" "uint8_t *""'");
18522  }
18523  arg2 = reinterpret_cast< uint8_t * >(argp2);
18524  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
18525  if (!SWIG_IsOK(ecode3)) {
18526  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribCommunity_write" "', argument " "3"" of type '" "size_t""'");
18527  }
18528  arg3 = static_cast< size_t >(val3);
18529  result = ((libbgp::BgpPathAttribCommunity const *)arg1)->write(arg2,arg3);
18530  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
18531  return resultobj;
18532 fail:
18533  return NULL;
18534 }
18535 
18536 
18537 SWIGINTERN PyObject *_wrap_BgpPathAttribCommunity_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18538  PyObject *resultobj = 0;
18540  size_t arg2 ;
18541  uint8_t **arg3 = (uint8_t **) 0 ;
18542  size_t *arg4 = (size_t *) 0 ;
18543  void *argp1 = 0 ;
18544  int res1 = 0 ;
18545  size_t val2 ;
18546  int ecode2 = 0 ;
18547  void *argp3 = 0 ;
18548  int res3 = 0 ;
18549  void *argp4 = 0 ;
18550  int res4 = 0 ;
18551  PyObject * obj0 = 0 ;
18552  PyObject * obj1 = 0 ;
18553  PyObject * obj2 = 0 ;
18554  PyObject * obj3 = 0 ;
18555  ssize_t result;
18556 
18557  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttribCommunity_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18558  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribCommunity, 0 | 0 );
18559  if (!SWIG_IsOK(res1)) {
18560  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribCommunity_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttribCommunity const *""'");
18561  }
18562  arg1 = reinterpret_cast< libbgp::BgpPathAttribCommunity * >(argp1);
18563  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
18564  if (!SWIG_IsOK(ecode2)) {
18565  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribCommunity_doPrint" "', argument " "2"" of type '" "size_t""'");
18566  }
18567  arg2 = static_cast< size_t >(val2);
18568  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
18569  if (!SWIG_IsOK(res3)) {
18570  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttribCommunity_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
18571  }
18572  arg3 = reinterpret_cast< uint8_t ** >(argp3);
18573  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
18574  if (!SWIG_IsOK(res4)) {
18575  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttribCommunity_doPrint" "', argument " "4"" of type '" "size_t *""'");
18576  }
18577  arg4 = reinterpret_cast< size_t * >(argp4);
18578  result = ((libbgp::BgpPathAttribCommunity const *)arg1)->doPrint(arg2,arg3,arg4);
18579  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
18580  return resultobj;
18581 fail:
18582  return NULL;
18583 }
18584 
18585 
18586 SWIGINTERN PyObject *_wrap_BgpPathAttribCommunity_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18587  PyObject *resultobj = 0;
18589  void *argp1 = 0 ;
18590  int res1 = 0 ;
18591  PyObject * obj0 = 0 ;
18592  ssize_t result;
18593 
18594  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribCommunity_length",&obj0)) SWIG_fail;
18595  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribCommunity, 0 | 0 );
18596  if (!SWIG_IsOK(res1)) {
18597  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribCommunity_length" "', argument " "1"" of type '" "libbgp::BgpPathAttribCommunity const *""'");
18598  }
18599  arg1 = reinterpret_cast< libbgp::BgpPathAttribCommunity * >(argp1);
18600  result = ((libbgp::BgpPathAttribCommunity const *)arg1)->length();
18601  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
18602  return resultobj;
18603 fail:
18604  return NULL;
18605 }
18606 
18607 
18608 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribCommunity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18609  PyObject *resultobj = 0;
18611  void *argp1 = 0 ;
18612  int res1 = 0 ;
18613  PyObject * obj0 = 0 ;
18614 
18615  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribCommunity",&obj0)) SWIG_fail;
18616  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribCommunity, SWIG_POINTER_DISOWN | 0 );
18617  if (!SWIG_IsOK(res1)) {
18618  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribCommunity" "', argument " "1"" of type '" "libbgp::BgpPathAttribCommunity *""'");
18619  }
18620  arg1 = reinterpret_cast< libbgp::BgpPathAttribCommunity * >(argp1);
18621  delete arg1;
18622  resultobj = SWIG_Py_Void();
18623  return resultobj;
18624 fail:
18625  return NULL;
18626 }
18627 
18628 
18629 SWIGINTERN PyObject *BgpPathAttribCommunity_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18630  PyObject *obj;
18631  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
18632  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribCommunity, SWIG_NewClientData(obj));
18633  return SWIG_Py_Void();
18634 }
18635 
18636 SWIGINTERN PyObject *_wrap_new_BgpPathAttribMpNlriBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18637  PyObject *resultobj = 0;
18639  void *argp1 = 0 ;
18640  int res1 = 0 ;
18641  PyObject * obj0 = 0 ;
18642  libbgp::BgpPathAttribMpNlriBase *result = 0 ;
18643 
18644  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpPathAttribMpNlriBase",&obj0)) SWIG_fail;
18645  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
18646  if (!SWIG_IsOK(res1)) {
18647  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribMpNlriBase" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
18648  }
18649  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
18651  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribMpNlriBase, SWIG_POINTER_NEW | 0 );
18652  return resultobj;
18653 fail:
18654  return NULL;
18655 }
18656 
18657 
18658 SWIGINTERN PyObject *_wrap_BgpPathAttribMpNlriBase_GetAfiFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18659  PyObject *resultobj = 0;
18660  uint8_t *arg1 = (uint8_t *) 0 ;
18661  size_t arg2 ;
18662  void *argp1 = 0 ;
18663  int res1 = 0 ;
18664  size_t val2 ;
18665  int ecode2 = 0 ;
18666  PyObject * obj0 = 0 ;
18667  PyObject * obj1 = 0 ;
18668  int16_t result;
18669 
18670  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribMpNlriBase_GetAfiFromBuffer",&obj0,&obj1)) SWIG_fail;
18671  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 | 0 );
18672  if (!SWIG_IsOK(res1)) {
18673  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpNlriBase_GetAfiFromBuffer" "', argument " "1"" of type '" "uint8_t const *""'");
18674  }
18675  arg1 = reinterpret_cast< uint8_t * >(argp1);
18676  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
18677  if (!SWIG_IsOK(ecode2)) {
18678  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribMpNlriBase_GetAfiFromBuffer" "', argument " "2"" of type '" "size_t""'");
18679  }
18680  arg2 = static_cast< size_t >(val2);
18681  result = (int16_t)libbgp::BgpPathAttribMpNlriBase::GetAfiFromBuffer((unsigned char const *)arg1,arg2);
18682  resultobj = SWIG_From_short(static_cast< short >(result));
18683  return resultobj;
18684 fail:
18685  return NULL;
18686 }
18687 
18688 
18689 SWIGINTERN PyObject *_wrap_BgpPathAttribMpNlriBase_afi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18690  PyObject *resultobj = 0;
18692  uint16_t arg2 ;
18693  void *argp1 = 0 ;
18694  int res1 = 0 ;
18695  unsigned short val2 ;
18696  int ecode2 = 0 ;
18697  PyObject * obj0 = 0 ;
18698  PyObject * obj1 = 0 ;
18699 
18700  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribMpNlriBase_afi_set",&obj0,&obj1)) SWIG_fail;
18701  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpNlriBase, 0 | 0 );
18702  if (!SWIG_IsOK(res1)) {
18703  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpNlriBase_afi_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpNlriBase *""'");
18704  }
18705  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpNlriBase * >(argp1);
18706  ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
18707  if (!SWIG_IsOK(ecode2)) {
18708  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribMpNlriBase_afi_set" "', argument " "2"" of type '" "uint16_t""'");
18709  }
18710  arg2 = static_cast< uint16_t >(val2);
18711  if (arg1) (arg1)->afi = arg2;
18712  resultobj = SWIG_Py_Void();
18713  return resultobj;
18714 fail:
18715  return NULL;
18716 }
18717 
18718 
18719 SWIGINTERN PyObject *_wrap_BgpPathAttribMpNlriBase_afi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18720  PyObject *resultobj = 0;
18722  void *argp1 = 0 ;
18723  int res1 = 0 ;
18724  PyObject * obj0 = 0 ;
18725  uint16_t result;
18726 
18727  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpNlriBase_afi_get",&obj0)) SWIG_fail;
18728  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpNlriBase, 0 | 0 );
18729  if (!SWIG_IsOK(res1)) {
18730  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpNlriBase_afi_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpNlriBase *""'");
18731  }
18732  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpNlriBase * >(argp1);
18733  result = (uint16_t) ((arg1)->afi);
18734  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
18735  return resultobj;
18736 fail:
18737  return NULL;
18738 }
18739 
18740 
18741 SWIGINTERN PyObject *_wrap_BgpPathAttribMpNlriBase_safi_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18742  PyObject *resultobj = 0;
18744  uint8_t arg2 ;
18745  void *argp1 = 0 ;
18746  int res1 = 0 ;
18747  unsigned char val2 ;
18748  int ecode2 = 0 ;
18749  PyObject * obj0 = 0 ;
18750  PyObject * obj1 = 0 ;
18751 
18752  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribMpNlriBase_safi_set",&obj0,&obj1)) SWIG_fail;
18753  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpNlriBase, 0 | 0 );
18754  if (!SWIG_IsOK(res1)) {
18755  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpNlriBase_safi_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpNlriBase *""'");
18756  }
18757  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpNlriBase * >(argp1);
18758  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18759  if (!SWIG_IsOK(ecode2)) {
18760  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribMpNlriBase_safi_set" "', argument " "2"" of type '" "uint8_t""'");
18761  }
18762  arg2 = static_cast< uint8_t >(val2);
18763  if (arg1) (arg1)->safi = arg2;
18764  resultobj = SWIG_Py_Void();
18765  return resultobj;
18766 fail:
18767  return NULL;
18768 }
18769 
18770 
18771 SWIGINTERN PyObject *_wrap_BgpPathAttribMpNlriBase_safi_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18772  PyObject *resultobj = 0;
18774  void *argp1 = 0 ;
18775  int res1 = 0 ;
18776  PyObject * obj0 = 0 ;
18777  uint8_t result;
18778 
18779  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpNlriBase_safi_get",&obj0)) SWIG_fail;
18780  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpNlriBase, 0 | 0 );
18781  if (!SWIG_IsOK(res1)) {
18782  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpNlriBase_safi_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpNlriBase *""'");
18783  }
18784  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpNlriBase * >(argp1);
18785  result = (uint8_t) ((arg1)->safi);
18786  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18787  return resultobj;
18788 fail:
18789  return NULL;
18790 }
18791 
18792 
18793 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribMpNlriBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18794  PyObject *resultobj = 0;
18796  void *argp1 = 0 ;
18797  int res1 = 0 ;
18798  PyObject * obj0 = 0 ;
18799 
18800  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribMpNlriBase",&obj0)) SWIG_fail;
18801  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpNlriBase, SWIG_POINTER_DISOWN | 0 );
18802  if (!SWIG_IsOK(res1)) {
18803  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribMpNlriBase" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpNlriBase *""'");
18804  }
18805  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpNlriBase * >(argp1);
18806  delete arg1;
18807  resultobj = SWIG_Py_Void();
18808  return resultobj;
18809 fail:
18810  return NULL;
18811 }
18812 
18813 
18814 SWIGINTERN PyObject *BgpPathAttribMpNlriBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18815  PyObject *obj;
18816  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
18817  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribMpNlriBase, SWIG_NewClientData(obj));
18818  return SWIG_Py_Void();
18819 }
18820 
18821 SWIGINTERN PyObject *_wrap_new_BgpPathAttribMpReachNlriIpv6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18822  PyObject *resultobj = 0;
18824  void *argp1 = 0 ;
18825  int res1 = 0 ;
18826  PyObject * obj0 = 0 ;
18828 
18829  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpPathAttribMpReachNlriIpv6",&obj0)) SWIG_fail;
18830  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
18831  if (!SWIG_IsOK(res1)) {
18832  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribMpReachNlriIpv6" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
18833  }
18834  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
18836  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6, SWIG_POINTER_NEW | 0 );
18837  return resultobj;
18838 fail:
18839  return NULL;
18840 }
18841 
18842 
18843 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriIpv6_nexthop_global_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18844  PyObject *resultobj = 0;
18846  uint8_t *arg2 ;
18847  void *argp1 = 0 ;
18848  int res1 = 0 ;
18849  void *argp2 = 0 ;
18850  int res2 = 0 ;
18851  PyObject * obj0 = 0 ;
18852  PyObject * obj1 = 0 ;
18853 
18854  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribMpReachNlriIpv6_nexthop_global_set",&obj0,&obj1)) SWIG_fail;
18855  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6, 0 | 0 );
18856  if (!SWIG_IsOK(res1)) {
18857  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriIpv6_nexthop_global_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriIpv6 *""'");
18858  }
18859  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriIpv6 * >(argp1);
18860  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
18861  if (!SWIG_IsOK(res2)) {
18862  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribMpReachNlriIpv6_nexthop_global_set" "', argument " "2"" of type '" "uint8_t [16]""'");
18863  }
18864  arg2 = reinterpret_cast< uint8_t * >(argp2);
18865  {
18866  if (arg2) {
18867  size_t ii = 0;
18868  for (; ii < (size_t)16; ++ii) *(uint8_t *)&arg1->nexthop_global[ii] = *((uint8_t *)arg2 + ii);
18869  } else {
18870  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""nexthop_global""' of type '""uint8_t [16]""'");
18871  }
18872  }
18873  resultobj = SWIG_Py_Void();
18874  return resultobj;
18875 fail:
18876  return NULL;
18877 }
18878 
18879 
18880 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriIpv6_nexthop_global_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18881  PyObject *resultobj = 0;
18883  void *argp1 = 0 ;
18884  int res1 = 0 ;
18885  PyObject * obj0 = 0 ;
18886  uint8_t *result = 0 ;
18887 
18888  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpReachNlriIpv6_nexthop_global_get",&obj0)) SWIG_fail;
18889  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6, 0 | 0 );
18890  if (!SWIG_IsOK(res1)) {
18891  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriIpv6_nexthop_global_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriIpv6 *""'");
18892  }
18893  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriIpv6 * >(argp1);
18894  result = (uint8_t *)(uint8_t *) ((arg1)->nexthop_global);
18895  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
18896  return resultobj;
18897 fail:
18898  return NULL;
18899 }
18900 
18901 
18902 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriIpv6_nexthop_linklocal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18903  PyObject *resultobj = 0;
18905  uint8_t *arg2 ;
18906  void *argp1 = 0 ;
18907  int res1 = 0 ;
18908  void *argp2 = 0 ;
18909  int res2 = 0 ;
18910  PyObject * obj0 = 0 ;
18911  PyObject * obj1 = 0 ;
18912 
18913  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribMpReachNlriIpv6_nexthop_linklocal_set",&obj0,&obj1)) SWIG_fail;
18914  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6, 0 | 0 );
18915  if (!SWIG_IsOK(res1)) {
18916  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriIpv6_nexthop_linklocal_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriIpv6 *""'");
18917  }
18918  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriIpv6 * >(argp1);
18919  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
18920  if (!SWIG_IsOK(res2)) {
18921  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribMpReachNlriIpv6_nexthop_linklocal_set" "', argument " "2"" of type '" "uint8_t [16]""'");
18922  }
18923  arg2 = reinterpret_cast< uint8_t * >(argp2);
18924  {
18925  if (arg2) {
18926  size_t ii = 0;
18927  for (; ii < (size_t)16; ++ii) *(uint8_t *)&arg1->nexthop_linklocal[ii] = *((uint8_t *)arg2 + ii);
18928  } else {
18929  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""nexthop_linklocal""' of type '""uint8_t [16]""'");
18930  }
18931  }
18932  resultobj = SWIG_Py_Void();
18933  return resultobj;
18934 fail:
18935  return NULL;
18936 }
18937 
18938 
18939 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriIpv6_nexthop_linklocal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18940  PyObject *resultobj = 0;
18942  void *argp1 = 0 ;
18943  int res1 = 0 ;
18944  PyObject * obj0 = 0 ;
18945  uint8_t *result = 0 ;
18946 
18947  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpReachNlriIpv6_nexthop_linklocal_get",&obj0)) SWIG_fail;
18948  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6, 0 | 0 );
18949  if (!SWIG_IsOK(res1)) {
18950  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriIpv6_nexthop_linklocal_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriIpv6 *""'");
18951  }
18952  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriIpv6 * >(argp1);
18953  result = (uint8_t *)(uint8_t *) ((arg1)->nexthop_linklocal);
18954  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
18955  return resultobj;
18956 fail:
18957  return NULL;
18958 }
18959 
18960 
18961 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriIpv6_nlri_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18962  PyObject *resultobj = 0;
18964  std::vector< libbgp::Prefix6 > *arg2 = (std::vector< libbgp::Prefix6 > *) 0 ;
18965  void *argp1 = 0 ;
18966  int res1 = 0 ;
18967  void *argp2 = 0 ;
18968  int res2 = 0 ;
18969  PyObject * obj0 = 0 ;
18970  PyObject * obj1 = 0 ;
18971 
18972  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribMpReachNlriIpv6_nlri_set",&obj0,&obj1)) SWIG_fail;
18973  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6, 0 | 0 );
18974  if (!SWIG_IsOK(res1)) {
18975  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriIpv6_nlri_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriIpv6 *""'");
18976  }
18977  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriIpv6 * >(argp1);
18978  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0 | 0 );
18979  if (!SWIG_IsOK(res2)) {
18980  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribMpReachNlriIpv6_nlri_set" "', argument " "2"" of type '" "std::vector< libbgp::Prefix6 > *""'");
18981  }
18982  arg2 = reinterpret_cast< std::vector< libbgp::Prefix6 > * >(argp2);
18983  if (arg1) (arg1)->nlri = *arg2;
18984  resultobj = SWIG_Py_Void();
18985  return resultobj;
18986 fail:
18987  return NULL;
18988 }
18989 
18990 
18991 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriIpv6_nlri_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18992  PyObject *resultobj = 0;
18994  void *argp1 = 0 ;
18995  int res1 = 0 ;
18996  PyObject * obj0 = 0 ;
18997  std::vector< libbgp::Prefix6 > *result = 0 ;
18998 
18999  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpReachNlriIpv6_nlri_get",&obj0)) SWIG_fail;
19000  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6, 0 | 0 );
19001  if (!SWIG_IsOK(res1)) {
19002  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriIpv6_nlri_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriIpv6 *""'");
19003  }
19004  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriIpv6 * >(argp1);
19005  result = (std::vector< libbgp::Prefix6 > *)& ((arg1)->nlri);
19006  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0 | 0 );
19007  return resultobj;
19008 fail:
19009  return NULL;
19010 }
19011 
19012 
19013 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriIpv6_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19014  PyObject *resultobj = 0;
19016  void *argp1 = 0 ;
19017  int res1 = 0 ;
19018  PyObject * obj0 = 0 ;
19019  libbgp::BgpPathAttrib *result = 0 ;
19020 
19021  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpReachNlriIpv6_clone",&obj0)) SWIG_fail;
19022  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6, 0 | 0 );
19023  if (!SWIG_IsOK(res1)) {
19024  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriIpv6_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriIpv6 const *""'");
19025  }
19026  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriIpv6 * >(argp1);
19027  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttribMpReachNlriIpv6 const *)arg1)->clone();
19028  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
19029  return resultobj;
19030 fail:
19031  return NULL;
19032 }
19033 
19034 
19035 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriIpv6_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19036  PyObject *resultobj = 0;
19038  uint8_t *arg2 = (uint8_t *) 0 ;
19039  size_t arg3 ;
19040  void *argp1 = 0 ;
19041  int res1 = 0 ;
19042  void *argp2 = 0 ;
19043  int res2 = 0 ;
19044  size_t val3 ;
19045  int ecode3 = 0 ;
19046  PyObject * obj0 = 0 ;
19047  PyObject * obj1 = 0 ;
19048  PyObject * obj2 = 0 ;
19049  ssize_t result;
19050 
19051  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribMpReachNlriIpv6_parse",&obj0,&obj1,&obj2)) SWIG_fail;
19052  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6, 0 | 0 );
19053  if (!SWIG_IsOK(res1)) {
19054  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriIpv6_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriIpv6 *""'");
19055  }
19056  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriIpv6 * >(argp1);
19057  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
19058  if (!SWIG_IsOK(res2)) {
19059  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribMpReachNlriIpv6_parse" "', argument " "2"" of type '" "uint8_t const *""'");
19060  }
19061  arg2 = reinterpret_cast< uint8_t * >(argp2);
19062  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
19063  if (!SWIG_IsOK(ecode3)) {
19064  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribMpReachNlriIpv6_parse" "', argument " "3"" of type '" "size_t""'");
19065  }
19066  arg3 = static_cast< size_t >(val3);
19067  result = (arg1)->parse((uint8_t const *)arg2,arg3);
19068  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
19069  return resultobj;
19070 fail:
19071  return NULL;
19072 }
19073 
19074 
19075 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriIpv6_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19076  PyObject *resultobj = 0;
19078  uint8_t *arg2 = (uint8_t *) 0 ;
19079  size_t arg3 ;
19080  void *argp1 = 0 ;
19081  int res1 = 0 ;
19082  void *argp2 = 0 ;
19083  int res2 = 0 ;
19084  size_t val3 ;
19085  int ecode3 = 0 ;
19086  PyObject * obj0 = 0 ;
19087  PyObject * obj1 = 0 ;
19088  PyObject * obj2 = 0 ;
19089  ssize_t result;
19090 
19091  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribMpReachNlriIpv6_write",&obj0,&obj1,&obj2)) SWIG_fail;
19092  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6, 0 | 0 );
19093  if (!SWIG_IsOK(res1)) {
19094  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriIpv6_write" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriIpv6 const *""'");
19095  }
19096  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriIpv6 * >(argp1);
19097  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
19098  if (!SWIG_IsOK(res2)) {
19099  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribMpReachNlriIpv6_write" "', argument " "2"" of type '" "uint8_t *""'");
19100  }
19101  arg2 = reinterpret_cast< uint8_t * >(argp2);
19102  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
19103  if (!SWIG_IsOK(ecode3)) {
19104  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribMpReachNlriIpv6_write" "', argument " "3"" of type '" "size_t""'");
19105  }
19106  arg3 = static_cast< size_t >(val3);
19107  result = ((libbgp::BgpPathAttribMpReachNlriIpv6 const *)arg1)->write(arg2,arg3);
19108  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
19109  return resultobj;
19110 fail:
19111  return NULL;
19112 }
19113 
19114 
19115 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriIpv6_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19116  PyObject *resultobj = 0;
19118  size_t arg2 ;
19119  uint8_t **arg3 = (uint8_t **) 0 ;
19120  size_t *arg4 = (size_t *) 0 ;
19121  void *argp1 = 0 ;
19122  int res1 = 0 ;
19123  size_t val2 ;
19124  int ecode2 = 0 ;
19125  void *argp3 = 0 ;
19126  int res3 = 0 ;
19127  void *argp4 = 0 ;
19128  int res4 = 0 ;
19129  PyObject * obj0 = 0 ;
19130  PyObject * obj1 = 0 ;
19131  PyObject * obj2 = 0 ;
19132  PyObject * obj3 = 0 ;
19133  ssize_t result;
19134 
19135  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttribMpReachNlriIpv6_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19136  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6, 0 | 0 );
19137  if (!SWIG_IsOK(res1)) {
19138  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriIpv6_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriIpv6 const *""'");
19139  }
19140  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriIpv6 * >(argp1);
19141  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
19142  if (!SWIG_IsOK(ecode2)) {
19143  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribMpReachNlriIpv6_doPrint" "', argument " "2"" of type '" "size_t""'");
19144  }
19145  arg2 = static_cast< size_t >(val2);
19146  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
19147  if (!SWIG_IsOK(res3)) {
19148  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttribMpReachNlriIpv6_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
19149  }
19150  arg3 = reinterpret_cast< uint8_t ** >(argp3);
19151  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
19152  if (!SWIG_IsOK(res4)) {
19153  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttribMpReachNlriIpv6_doPrint" "', argument " "4"" of type '" "size_t *""'");
19154  }
19155  arg4 = reinterpret_cast< size_t * >(argp4);
19156  result = ((libbgp::BgpPathAttribMpReachNlriIpv6 const *)arg1)->doPrint(arg2,arg3,arg4);
19157  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
19158  return resultobj;
19159 fail:
19160  return NULL;
19161 }
19162 
19163 
19164 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriIpv6_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19165  PyObject *resultobj = 0;
19167  void *argp1 = 0 ;
19168  int res1 = 0 ;
19169  PyObject * obj0 = 0 ;
19170  ssize_t result;
19171 
19172  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpReachNlriIpv6_length",&obj0)) SWIG_fail;
19173  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6, 0 | 0 );
19174  if (!SWIG_IsOK(res1)) {
19175  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriIpv6_length" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriIpv6 const *""'");
19176  }
19177  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriIpv6 * >(argp1);
19178  result = ((libbgp::BgpPathAttribMpReachNlriIpv6 const *)arg1)->length();
19179  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
19180  return resultobj;
19181 fail:
19182  return NULL;
19183 }
19184 
19185 
19186 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribMpReachNlriIpv6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19187  PyObject *resultobj = 0;
19189  void *argp1 = 0 ;
19190  int res1 = 0 ;
19191  PyObject * obj0 = 0 ;
19192 
19193  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribMpReachNlriIpv6",&obj0)) SWIG_fail;
19194  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6, SWIG_POINTER_DISOWN | 0 );
19195  if (!SWIG_IsOK(res1)) {
19196  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribMpReachNlriIpv6" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriIpv6 *""'");
19197  }
19198  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriIpv6 * >(argp1);
19199  delete arg1;
19200  resultobj = SWIG_Py_Void();
19201  return resultobj;
19202 fail:
19203  return NULL;
19204 }
19205 
19206 
19207 SWIGINTERN PyObject *BgpPathAttribMpReachNlriIpv6_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19208  PyObject *obj;
19209  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
19210  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriIpv6, SWIG_NewClientData(obj));
19211  return SWIG_Py_Void();
19212 }
19213 
19214 SWIGINTERN PyObject *_wrap_new_BgpPathAttribMpReachNlriUnknow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19215  PyObject *resultobj = 0;
19217  void *argp1 = 0 ;
19218  int res1 = 0 ;
19219  PyObject * obj0 = 0 ;
19221 
19222  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpPathAttribMpReachNlriUnknow",&obj0)) SWIG_fail;
19223  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
19224  if (!SWIG_IsOK(res1)) {
19225  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribMpReachNlriUnknow" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
19226  }
19227  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
19229  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriUnknow, SWIG_POINTER_NEW | 0 );
19230  return resultobj;
19231 fail:
19232  return NULL;
19233 }
19234 
19235 
19236 SWIGINTERN PyObject *_wrap_new_BgpPathAttribMpReachNlriUnknow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19237  PyObject *resultobj = 0;
19239  uint8_t *arg2 = (uint8_t *) 0 ;
19240  size_t arg3 ;
19241  uint8_t *arg4 = (uint8_t *) 0 ;
19242  size_t arg5 ;
19243  void *argp1 = 0 ;
19244  int res1 = 0 ;
19245  void *argp2 = 0 ;
19246  int res2 = 0 ;
19247  size_t val3 ;
19248  int ecode3 = 0 ;
19249  void *argp4 = 0 ;
19250  int res4 = 0 ;
19251  size_t val5 ;
19252  int ecode5 = 0 ;
19253  PyObject * obj0 = 0 ;
19254  PyObject * obj1 = 0 ;
19255  PyObject * obj2 = 0 ;
19256  PyObject * obj3 = 0 ;
19257  PyObject * obj4 = 0 ;
19259 
19260  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_BgpPathAttribMpReachNlriUnknow",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19261  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
19262  if (!SWIG_IsOK(res1)) {
19263  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribMpReachNlriUnknow" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
19264  }
19265  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
19266  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
19267  if (!SWIG_IsOK(res2)) {
19268  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BgpPathAttribMpReachNlriUnknow" "', argument " "2"" of type '" "uint8_t const *""'");
19269  }
19270  arg2 = reinterpret_cast< uint8_t * >(argp2);
19271  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
19272  if (!SWIG_IsOK(ecode3)) {
19273  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BgpPathAttribMpReachNlriUnknow" "', argument " "3"" of type '" "size_t""'");
19274  }
19275  arg3 = static_cast< size_t >(val3);
19276  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
19277  if (!SWIG_IsOK(res4)) {
19278  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BgpPathAttribMpReachNlriUnknow" "', argument " "4"" of type '" "uint8_t const *""'");
19279  }
19280  arg4 = reinterpret_cast< uint8_t * >(argp4);
19281  ecode5 = SWIG_AsVal_size_t(obj4, &val5);
19282  if (!SWIG_IsOK(ecode5)) {
19283  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_BgpPathAttribMpReachNlriUnknow" "', argument " "5"" of type '" "size_t""'");
19284  }
19285  arg5 = static_cast< size_t >(val5);
19286  result = (libbgp::BgpPathAttribMpReachNlriUnknow *)new libbgp::BgpPathAttribMpReachNlriUnknow(arg1,(uint8_t const *)arg2,arg3,(uint8_t const *)arg4,arg5);
19287  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriUnknow, SWIG_POINTER_NEW | 0 );
19288  return resultobj;
19289 fail:
19290  return NULL;
19291 }
19292 
19293 
19294 SWIGINTERN PyObject *_wrap_new_BgpPathAttribMpReachNlriUnknow(PyObject *self, PyObject *args) {
19295  Py_ssize_t argc;
19296  PyObject *argv[6] = {
19297  0
19298  };
19299  Py_ssize_t ii;
19300 
19301  if (!PyTuple_Check(args)) SWIG_fail;
19302  argc = args ? PyObject_Length(args) : 0;
19303  for (ii = 0; (ii < 5) && (ii < argc); ii++) {
19304  argv[ii] = PyTuple_GET_ITEM(args,ii);
19305  }
19306  if (argc == 1) {
19307  int _v;
19308  void *vptr = 0;
19309  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
19310  _v = SWIG_CheckState(res);
19311  if (_v) {
19312  return _wrap_new_BgpPathAttribMpReachNlriUnknow__SWIG_0(self, args);
19313  }
19314  }
19315  if (argc == 5) {
19316  int _v;
19317  void *vptr = 0;
19318  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
19319  _v = SWIG_CheckState(res);
19320  if (_v) {
19321  void *vptr = 0;
19322  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
19323  _v = SWIG_CheckState(res);
19324  if (_v) {
19325  {
19326  int res = SWIG_AsVal_size_t(argv[2], NULL);
19327  _v = SWIG_CheckState(res);
19328  }
19329  if (_v) {
19330  void *vptr = 0;
19331  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
19332  _v = SWIG_CheckState(res);
19333  if (_v) {
19334  {
19335  int res = SWIG_AsVal_size_t(argv[4], NULL);
19336  _v = SWIG_CheckState(res);
19337  }
19338  if (_v) {
19339  return _wrap_new_BgpPathAttribMpReachNlriUnknow__SWIG_1(self, args);
19340  }
19341  }
19342  }
19343  }
19344  }
19345  }
19346 
19347 fail:
19348  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BgpPathAttribMpReachNlriUnknow'.\n"
19349  " Possible C/C++ prototypes are:\n"
19350  " libbgp::BgpPathAttribMpReachNlriUnknow::BgpPathAttribMpReachNlriUnknow(libbgp::BgpLogHandler *)\n"
19351  " libbgp::BgpPathAttribMpReachNlriUnknow::BgpPathAttribMpReachNlriUnknow(libbgp::BgpLogHandler *,uint8_t const *,size_t,uint8_t const *,size_t)\n");
19352  return 0;
19353 }
19354 
19355 
19356 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribMpReachNlriUnknow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19357  PyObject *resultobj = 0;
19359  void *argp1 = 0 ;
19360  int res1 = 0 ;
19361  PyObject * obj0 = 0 ;
19362 
19363  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribMpReachNlriUnknow",&obj0)) SWIG_fail;
19364  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriUnknow, SWIG_POINTER_DISOWN | 0 );
19365  if (!SWIG_IsOK(res1)) {
19366  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribMpReachNlriUnknow" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriUnknow *""'");
19367  }
19368  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriUnknow * >(argp1);
19369  delete arg1;
19370  resultobj = SWIG_Py_Void();
19371  return resultobj;
19372 fail:
19373  return NULL;
19374 }
19375 
19376 
19377 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriUnknow_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19378  PyObject *resultobj = 0;
19380  void *argp1 = 0 ;
19381  int res1 = 0 ;
19382  PyObject * obj0 = 0 ;
19383  libbgp::BgpPathAttrib *result = 0 ;
19384 
19385  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpReachNlriUnknow_clone",&obj0)) SWIG_fail;
19386  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriUnknow, 0 | 0 );
19387  if (!SWIG_IsOK(res1)) {
19388  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriUnknow_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriUnknow const *""'");
19389  }
19390  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriUnknow * >(argp1);
19391  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttribMpReachNlriUnknow const *)arg1)->clone();
19392  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
19393  return resultobj;
19394 fail:
19395  return NULL;
19396 }
19397 
19398 
19399 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriUnknow_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19400  PyObject *resultobj = 0;
19402  uint8_t *arg2 = (uint8_t *) 0 ;
19403  size_t arg3 ;
19404  void *argp1 = 0 ;
19405  int res1 = 0 ;
19406  void *argp2 = 0 ;
19407  int res2 = 0 ;
19408  size_t val3 ;
19409  int ecode3 = 0 ;
19410  PyObject * obj0 = 0 ;
19411  PyObject * obj1 = 0 ;
19412  PyObject * obj2 = 0 ;
19413  ssize_t result;
19414 
19415  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribMpReachNlriUnknow_parse",&obj0,&obj1,&obj2)) SWIG_fail;
19416  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriUnknow, 0 | 0 );
19417  if (!SWIG_IsOK(res1)) {
19418  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriUnknow_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriUnknow *""'");
19419  }
19420  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriUnknow * >(argp1);
19421  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
19422  if (!SWIG_IsOK(res2)) {
19423  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribMpReachNlriUnknow_parse" "', argument " "2"" of type '" "uint8_t const *""'");
19424  }
19425  arg2 = reinterpret_cast< uint8_t * >(argp2);
19426  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
19427  if (!SWIG_IsOK(ecode3)) {
19428  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribMpReachNlriUnknow_parse" "', argument " "3"" of type '" "size_t""'");
19429  }
19430  arg3 = static_cast< size_t >(val3);
19431  result = (arg1)->parse((uint8_t const *)arg2,arg3);
19432  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
19433  return resultobj;
19434 fail:
19435  return NULL;
19436 }
19437 
19438 
19439 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriUnknow_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19440  PyObject *resultobj = 0;
19442  uint8_t *arg2 = (uint8_t *) 0 ;
19443  size_t arg3 ;
19444  void *argp1 = 0 ;
19445  int res1 = 0 ;
19446  void *argp2 = 0 ;
19447  int res2 = 0 ;
19448  size_t val3 ;
19449  int ecode3 = 0 ;
19450  PyObject * obj0 = 0 ;
19451  PyObject * obj1 = 0 ;
19452  PyObject * obj2 = 0 ;
19453  ssize_t result;
19454 
19455  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribMpReachNlriUnknow_write",&obj0,&obj1,&obj2)) SWIG_fail;
19456  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriUnknow, 0 | 0 );
19457  if (!SWIG_IsOK(res1)) {
19458  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriUnknow_write" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriUnknow const *""'");
19459  }
19460  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriUnknow * >(argp1);
19461  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
19462  if (!SWIG_IsOK(res2)) {
19463  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribMpReachNlriUnknow_write" "', argument " "2"" of type '" "uint8_t *""'");
19464  }
19465  arg2 = reinterpret_cast< uint8_t * >(argp2);
19466  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
19467  if (!SWIG_IsOK(ecode3)) {
19468  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribMpReachNlriUnknow_write" "', argument " "3"" of type '" "size_t""'");
19469  }
19470  arg3 = static_cast< size_t >(val3);
19471  result = ((libbgp::BgpPathAttribMpReachNlriUnknow const *)arg1)->write(arg2,arg3);
19472  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
19473  return resultobj;
19474 fail:
19475  return NULL;
19476 }
19477 
19478 
19479 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriUnknow_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19480  PyObject *resultobj = 0;
19482  size_t arg2 ;
19483  uint8_t **arg3 = (uint8_t **) 0 ;
19484  size_t *arg4 = (size_t *) 0 ;
19485  void *argp1 = 0 ;
19486  int res1 = 0 ;
19487  size_t val2 ;
19488  int ecode2 = 0 ;
19489  void *argp3 = 0 ;
19490  int res3 = 0 ;
19491  void *argp4 = 0 ;
19492  int res4 = 0 ;
19493  PyObject * obj0 = 0 ;
19494  PyObject * obj1 = 0 ;
19495  PyObject * obj2 = 0 ;
19496  PyObject * obj3 = 0 ;
19497  ssize_t result;
19498 
19499  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttribMpReachNlriUnknow_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19500  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriUnknow, 0 | 0 );
19501  if (!SWIG_IsOK(res1)) {
19502  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriUnknow_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriUnknow const *""'");
19503  }
19504  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriUnknow * >(argp1);
19505  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
19506  if (!SWIG_IsOK(ecode2)) {
19507  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribMpReachNlriUnknow_doPrint" "', argument " "2"" of type '" "size_t""'");
19508  }
19509  arg2 = static_cast< size_t >(val2);
19510  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
19511  if (!SWIG_IsOK(res3)) {
19512  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttribMpReachNlriUnknow_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
19513  }
19514  arg3 = reinterpret_cast< uint8_t ** >(argp3);
19515  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
19516  if (!SWIG_IsOK(res4)) {
19517  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttribMpReachNlriUnknow_doPrint" "', argument " "4"" of type '" "size_t *""'");
19518  }
19519  arg4 = reinterpret_cast< size_t * >(argp4);
19520  result = ((libbgp::BgpPathAttribMpReachNlriUnknow const *)arg1)->doPrint(arg2,arg3,arg4);
19521  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
19522  return resultobj;
19523 fail:
19524  return NULL;
19525 }
19526 
19527 
19528 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriUnknow_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19529  PyObject *resultobj = 0;
19531  void *argp1 = 0 ;
19532  int res1 = 0 ;
19533  PyObject * obj0 = 0 ;
19534  ssize_t result;
19535 
19536  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpReachNlriUnknow_length",&obj0)) SWIG_fail;
19537  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriUnknow, 0 | 0 );
19538  if (!SWIG_IsOK(res1)) {
19539  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriUnknow_length" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriUnknow const *""'");
19540  }
19541  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriUnknow * >(argp1);
19542  result = ((libbgp::BgpPathAttribMpReachNlriUnknow const *)arg1)->length();
19543  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
19544  return resultobj;
19545 fail:
19546  return NULL;
19547 }
19548 
19549 
19550 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriUnknow_getNexthop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19551  PyObject *resultobj = 0;
19553  void *argp1 = 0 ;
19554  int res1 = 0 ;
19555  PyObject * obj0 = 0 ;
19556  uint8_t *result = 0 ;
19557 
19558  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpReachNlriUnknow_getNexthop",&obj0)) SWIG_fail;
19559  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriUnknow, 0 | 0 );
19560  if (!SWIG_IsOK(res1)) {
19561  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriUnknow_getNexthop" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriUnknow const *""'");
19562  }
19563  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriUnknow * >(argp1);
19564  result = (uint8_t *)((libbgp::BgpPathAttribMpReachNlriUnknow const *)arg1)->getNexthop();
19565  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
19566  return resultobj;
19567 fail:
19568  return NULL;
19569 }
19570 
19571 
19572 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriUnknow_getNlri(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19573  PyObject *resultobj = 0;
19575  void *argp1 = 0 ;
19576  int res1 = 0 ;
19577  PyObject * obj0 = 0 ;
19578  uint8_t *result = 0 ;
19579 
19580  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpReachNlriUnknow_getNlri",&obj0)) SWIG_fail;
19581  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriUnknow, 0 | 0 );
19582  if (!SWIG_IsOK(res1)) {
19583  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriUnknow_getNlri" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriUnknow const *""'");
19584  }
19585  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriUnknow * >(argp1);
19586  result = (uint8_t *)((libbgp::BgpPathAttribMpReachNlriUnknow const *)arg1)->getNlri();
19587  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
19588  return resultobj;
19589 fail:
19590  return NULL;
19591 }
19592 
19593 
19594 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriUnknow_getNexthopLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19595  PyObject *resultobj = 0;
19597  void *argp1 = 0 ;
19598  int res1 = 0 ;
19599  PyObject * obj0 = 0 ;
19600  size_t result;
19601 
19602  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpReachNlriUnknow_getNexthopLength",&obj0)) SWIG_fail;
19603  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriUnknow, 0 | 0 );
19604  if (!SWIG_IsOK(res1)) {
19605  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriUnknow_getNexthopLength" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriUnknow const *""'");
19606  }
19607  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriUnknow * >(argp1);
19608  result = ((libbgp::BgpPathAttribMpReachNlriUnknow const *)arg1)->getNexthopLength();
19609  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19610  return resultobj;
19611 fail:
19612  return NULL;
19613 }
19614 
19615 
19616 SWIGINTERN PyObject *_wrap_BgpPathAttribMpReachNlriUnknow_getNlriLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19617  PyObject *resultobj = 0;
19619  void *argp1 = 0 ;
19620  int res1 = 0 ;
19621  PyObject * obj0 = 0 ;
19622  size_t result;
19623 
19624  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpReachNlriUnknow_getNlriLength",&obj0)) SWIG_fail;
19625  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriUnknow, 0 | 0 );
19626  if (!SWIG_IsOK(res1)) {
19627  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpReachNlriUnknow_getNlriLength" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpReachNlriUnknow const *""'");
19628  }
19629  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpReachNlriUnknow * >(argp1);
19630  result = ((libbgp::BgpPathAttribMpReachNlriUnknow const *)arg1)->getNlriLength();
19631  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19632  return resultobj;
19633 fail:
19634  return NULL;
19635 }
19636 
19637 
19638 SWIGINTERN PyObject *BgpPathAttribMpReachNlriUnknow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19639  PyObject *obj;
19640  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
19641  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribMpReachNlriUnknow, SWIG_NewClientData(obj));
19642  return SWIG_Py_Void();
19643 }
19644 
19645 SWIGINTERN PyObject *_wrap_new_BgpPathAttribMpUnreachNlriIpv6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19646  PyObject *resultobj = 0;
19648  void *argp1 = 0 ;
19649  int res1 = 0 ;
19650  PyObject * obj0 = 0 ;
19652 
19653  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpPathAttribMpUnreachNlriIpv6",&obj0)) SWIG_fail;
19654  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
19655  if (!SWIG_IsOK(res1)) {
19656  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribMpUnreachNlriIpv6" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
19657  }
19658  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
19660  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriIpv6, SWIG_POINTER_NEW | 0 );
19661  return resultobj;
19662 fail:
19663  return NULL;
19664 }
19665 
19666 
19667 SWIGINTERN PyObject *_wrap_BgpPathAttribMpUnreachNlriIpv6_withdrawn_routes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19668  PyObject *resultobj = 0;
19670  std::vector< libbgp::Prefix6 > *arg2 = (std::vector< libbgp::Prefix6 > *) 0 ;
19671  void *argp1 = 0 ;
19672  int res1 = 0 ;
19673  void *argp2 = 0 ;
19674  int res2 = 0 ;
19675  PyObject * obj0 = 0 ;
19676  PyObject * obj1 = 0 ;
19677 
19678  if (!PyArg_ParseTuple(args,(char *)"OO:BgpPathAttribMpUnreachNlriIpv6_withdrawn_routes_set",&obj0,&obj1)) SWIG_fail;
19679  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriIpv6, 0 | 0 );
19680  if (!SWIG_IsOK(res1)) {
19681  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpUnreachNlriIpv6_withdrawn_routes_set" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriIpv6 *""'");
19682  }
19683  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriIpv6 * >(argp1);
19684  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0 | 0 );
19685  if (!SWIG_IsOK(res2)) {
19686  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribMpUnreachNlriIpv6_withdrawn_routes_set" "', argument " "2"" of type '" "std::vector< libbgp::Prefix6 > *""'");
19687  }
19688  arg2 = reinterpret_cast< std::vector< libbgp::Prefix6 > * >(argp2);
19689  if (arg1) (arg1)->withdrawn_routes = *arg2;
19690  resultobj = SWIG_Py_Void();
19691  return resultobj;
19692 fail:
19693  return NULL;
19694 }
19695 
19696 
19697 SWIGINTERN PyObject *_wrap_BgpPathAttribMpUnreachNlriIpv6_withdrawn_routes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19698  PyObject *resultobj = 0;
19700  void *argp1 = 0 ;
19701  int res1 = 0 ;
19702  PyObject * obj0 = 0 ;
19703  std::vector< libbgp::Prefix6 > *result = 0 ;
19704 
19705  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpUnreachNlriIpv6_withdrawn_routes_get",&obj0)) SWIG_fail;
19706  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriIpv6, 0 | 0 );
19707  if (!SWIG_IsOK(res1)) {
19708  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpUnreachNlriIpv6_withdrawn_routes_get" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriIpv6 *""'");
19709  }
19710  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriIpv6 * >(argp1);
19711  result = (std::vector< libbgp::Prefix6 > *)& ((arg1)->withdrawn_routes);
19712  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0 | 0 );
19713  return resultobj;
19714 fail:
19715  return NULL;
19716 }
19717 
19718 
19719 SWIGINTERN PyObject *_wrap_BgpPathAttribMpUnreachNlriIpv6_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19720  PyObject *resultobj = 0;
19722  void *argp1 = 0 ;
19723  int res1 = 0 ;
19724  PyObject * obj0 = 0 ;
19725  libbgp::BgpPathAttrib *result = 0 ;
19726 
19727  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpUnreachNlriIpv6_clone",&obj0)) SWIG_fail;
19728  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriIpv6, 0 | 0 );
19729  if (!SWIG_IsOK(res1)) {
19730  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpUnreachNlriIpv6_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriIpv6 const *""'");
19731  }
19732  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriIpv6 * >(argp1);
19733  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttribMpUnreachNlriIpv6 const *)arg1)->clone();
19734  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
19735  return resultobj;
19736 fail:
19737  return NULL;
19738 }
19739 
19740 
19741 SWIGINTERN PyObject *_wrap_BgpPathAttribMpUnreachNlriIpv6_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19742  PyObject *resultobj = 0;
19744  uint8_t *arg2 = (uint8_t *) 0 ;
19745  size_t arg3 ;
19746  void *argp1 = 0 ;
19747  int res1 = 0 ;
19748  void *argp2 = 0 ;
19749  int res2 = 0 ;
19750  size_t val3 ;
19751  int ecode3 = 0 ;
19752  PyObject * obj0 = 0 ;
19753  PyObject * obj1 = 0 ;
19754  PyObject * obj2 = 0 ;
19755  ssize_t result;
19756 
19757  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribMpUnreachNlriIpv6_parse",&obj0,&obj1,&obj2)) SWIG_fail;
19758  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriIpv6, 0 | 0 );
19759  if (!SWIG_IsOK(res1)) {
19760  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpUnreachNlriIpv6_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriIpv6 *""'");
19761  }
19762  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriIpv6 * >(argp1);
19763  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
19764  if (!SWIG_IsOK(res2)) {
19765  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribMpUnreachNlriIpv6_parse" "', argument " "2"" of type '" "uint8_t const *""'");
19766  }
19767  arg2 = reinterpret_cast< uint8_t * >(argp2);
19768  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
19769  if (!SWIG_IsOK(ecode3)) {
19770  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribMpUnreachNlriIpv6_parse" "', argument " "3"" of type '" "size_t""'");
19771  }
19772  arg3 = static_cast< size_t >(val3);
19773  result = (arg1)->parse((uint8_t const *)arg2,arg3);
19774  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
19775  return resultobj;
19776 fail:
19777  return NULL;
19778 }
19779 
19780 
19781 SWIGINTERN PyObject *_wrap_BgpPathAttribMpUnreachNlriIpv6_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19782  PyObject *resultobj = 0;
19784  uint8_t *arg2 = (uint8_t *) 0 ;
19785  size_t arg3 ;
19786  void *argp1 = 0 ;
19787  int res1 = 0 ;
19788  void *argp2 = 0 ;
19789  int res2 = 0 ;
19790  size_t val3 ;
19791  int ecode3 = 0 ;
19792  PyObject * obj0 = 0 ;
19793  PyObject * obj1 = 0 ;
19794  PyObject * obj2 = 0 ;
19795  ssize_t result;
19796 
19797  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribMpUnreachNlriIpv6_write",&obj0,&obj1,&obj2)) SWIG_fail;
19798  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriIpv6, 0 | 0 );
19799  if (!SWIG_IsOK(res1)) {
19800  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpUnreachNlriIpv6_write" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriIpv6 const *""'");
19801  }
19802  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriIpv6 * >(argp1);
19803  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
19804  if (!SWIG_IsOK(res2)) {
19805  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribMpUnreachNlriIpv6_write" "', argument " "2"" of type '" "uint8_t *""'");
19806  }
19807  arg2 = reinterpret_cast< uint8_t * >(argp2);
19808  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
19809  if (!SWIG_IsOK(ecode3)) {
19810  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribMpUnreachNlriIpv6_write" "', argument " "3"" of type '" "size_t""'");
19811  }
19812  arg3 = static_cast< size_t >(val3);
19813  result = ((libbgp::BgpPathAttribMpUnreachNlriIpv6 const *)arg1)->write(arg2,arg3);
19814  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
19815  return resultobj;
19816 fail:
19817  return NULL;
19818 }
19819 
19820 
19821 SWIGINTERN PyObject *_wrap_BgpPathAttribMpUnreachNlriIpv6_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19822  PyObject *resultobj = 0;
19824  size_t arg2 ;
19825  uint8_t **arg3 = (uint8_t **) 0 ;
19826  size_t *arg4 = (size_t *) 0 ;
19827  void *argp1 = 0 ;
19828  int res1 = 0 ;
19829  size_t val2 ;
19830  int ecode2 = 0 ;
19831  void *argp3 = 0 ;
19832  int res3 = 0 ;
19833  void *argp4 = 0 ;
19834  int res4 = 0 ;
19835  PyObject * obj0 = 0 ;
19836  PyObject * obj1 = 0 ;
19837  PyObject * obj2 = 0 ;
19838  PyObject * obj3 = 0 ;
19839  ssize_t result;
19840 
19841  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttribMpUnreachNlriIpv6_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19842  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriIpv6, 0 | 0 );
19843  if (!SWIG_IsOK(res1)) {
19844  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpUnreachNlriIpv6_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriIpv6 const *""'");
19845  }
19846  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriIpv6 * >(argp1);
19847  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
19848  if (!SWIG_IsOK(ecode2)) {
19849  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribMpUnreachNlriIpv6_doPrint" "', argument " "2"" of type '" "size_t""'");
19850  }
19851  arg2 = static_cast< size_t >(val2);
19852  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
19853  if (!SWIG_IsOK(res3)) {
19854  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttribMpUnreachNlriIpv6_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
19855  }
19856  arg3 = reinterpret_cast< uint8_t ** >(argp3);
19857  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
19858  if (!SWIG_IsOK(res4)) {
19859  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttribMpUnreachNlriIpv6_doPrint" "', argument " "4"" of type '" "size_t *""'");
19860  }
19861  arg4 = reinterpret_cast< size_t * >(argp4);
19862  result = ((libbgp::BgpPathAttribMpUnreachNlriIpv6 const *)arg1)->doPrint(arg2,arg3,arg4);
19863  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
19864  return resultobj;
19865 fail:
19866  return NULL;
19867 }
19868 
19869 
19870 SWIGINTERN PyObject *_wrap_BgpPathAttribMpUnreachNlriIpv6_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19871  PyObject *resultobj = 0;
19873  void *argp1 = 0 ;
19874  int res1 = 0 ;
19875  PyObject * obj0 = 0 ;
19876  ssize_t result;
19877 
19878  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpUnreachNlriIpv6_length",&obj0)) SWIG_fail;
19879  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriIpv6, 0 | 0 );
19880  if (!SWIG_IsOK(res1)) {
19881  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpUnreachNlriIpv6_length" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriIpv6 const *""'");
19882  }
19883  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriIpv6 * >(argp1);
19884  result = ((libbgp::BgpPathAttribMpUnreachNlriIpv6 const *)arg1)->length();
19885  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
19886  return resultobj;
19887 fail:
19888  return NULL;
19889 }
19890 
19891 
19892 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribMpUnreachNlriIpv6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19893  PyObject *resultobj = 0;
19895  void *argp1 = 0 ;
19896  int res1 = 0 ;
19897  PyObject * obj0 = 0 ;
19898 
19899  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribMpUnreachNlriIpv6",&obj0)) SWIG_fail;
19900  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriIpv6, SWIG_POINTER_DISOWN | 0 );
19901  if (!SWIG_IsOK(res1)) {
19902  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribMpUnreachNlriIpv6" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriIpv6 *""'");
19903  }
19904  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriIpv6 * >(argp1);
19905  delete arg1;
19906  resultobj = SWIG_Py_Void();
19907  return resultobj;
19908 fail:
19909  return NULL;
19910 }
19911 
19912 
19913 SWIGINTERN PyObject *BgpPathAttribMpUnreachNlriIpv6_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19914  PyObject *obj;
19915  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
19916  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriIpv6, SWIG_NewClientData(obj));
19917  return SWIG_Py_Void();
19918 }
19919 
19920 SWIGINTERN PyObject *_wrap_new_BgpPathAttribMpUnreachNlriUnknow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19921  PyObject *resultobj = 0;
19923  void *argp1 = 0 ;
19924  int res1 = 0 ;
19925  PyObject * obj0 = 0 ;
19927 
19928  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpPathAttribMpUnreachNlriUnknow",&obj0)) SWIG_fail;
19929  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
19930  if (!SWIG_IsOK(res1)) {
19931  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribMpUnreachNlriUnknow" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
19932  }
19933  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
19935  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriUnknow, SWIG_POINTER_NEW | 0 );
19936  return resultobj;
19937 fail:
19938  return NULL;
19939 }
19940 
19941 
19942 SWIGINTERN PyObject *_wrap_new_BgpPathAttribMpUnreachNlriUnknow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19943  PyObject *resultobj = 0;
19945  uint8_t *arg2 = (uint8_t *) 0 ;
19946  size_t arg3 ;
19947  void *argp1 = 0 ;
19948  int res1 = 0 ;
19949  void *argp2 = 0 ;
19950  int res2 = 0 ;
19951  size_t val3 ;
19952  int ecode3 = 0 ;
19953  PyObject * obj0 = 0 ;
19954  PyObject * obj1 = 0 ;
19955  PyObject * obj2 = 0 ;
19957 
19958  if (!PyArg_ParseTuple(args,(char *)"OOO:new_BgpPathAttribMpUnreachNlriUnknow",&obj0,&obj1,&obj2)) SWIG_fail;
19959  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
19960  if (!SWIG_IsOK(res1)) {
19961  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpPathAttribMpUnreachNlriUnknow" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
19962  }
19963  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
19964  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
19965  if (!SWIG_IsOK(res2)) {
19966  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BgpPathAttribMpUnreachNlriUnknow" "', argument " "2"" of type '" "uint8_t const *""'");
19967  }
19968  arg2 = reinterpret_cast< uint8_t * >(argp2);
19969  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
19970  if (!SWIG_IsOK(ecode3)) {
19971  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BgpPathAttribMpUnreachNlriUnknow" "', argument " "3"" of type '" "size_t""'");
19972  }
19973  arg3 = static_cast< size_t >(val3);
19974  result = (libbgp::BgpPathAttribMpUnreachNlriUnknow *)new libbgp::BgpPathAttribMpUnreachNlriUnknow(arg1,(uint8_t const *)arg2,arg3);
19975  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriUnknow, SWIG_POINTER_NEW | 0 );
19976  return resultobj;
19977 fail:
19978  return NULL;
19979 }
19980 
19981 
19982 SWIGINTERN PyObject *_wrap_new_BgpPathAttribMpUnreachNlriUnknow(PyObject *self, PyObject *args) {
19983  Py_ssize_t argc;
19984  PyObject *argv[4] = {
19985  0
19986  };
19987  Py_ssize_t ii;
19988 
19989  if (!PyTuple_Check(args)) SWIG_fail;
19990  argc = args ? PyObject_Length(args) : 0;
19991  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
19992  argv[ii] = PyTuple_GET_ITEM(args,ii);
19993  }
19994  if (argc == 1) {
19995  int _v;
19996  void *vptr = 0;
19997  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
19998  _v = SWIG_CheckState(res);
19999  if (_v) {
20000  return _wrap_new_BgpPathAttribMpUnreachNlriUnknow__SWIG_0(self, args);
20001  }
20002  }
20003  if (argc == 3) {
20004  int _v;
20005  void *vptr = 0;
20006  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
20007  _v = SWIG_CheckState(res);
20008  if (_v) {
20009  void *vptr = 0;
20010  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
20011  _v = SWIG_CheckState(res);
20012  if (_v) {
20013  {
20014  int res = SWIG_AsVal_size_t(argv[2], NULL);
20015  _v = SWIG_CheckState(res);
20016  }
20017  if (_v) {
20018  return _wrap_new_BgpPathAttribMpUnreachNlriUnknow__SWIG_1(self, args);
20019  }
20020  }
20021  }
20022  }
20023 
20024 fail:
20025  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BgpPathAttribMpUnreachNlriUnknow'.\n"
20026  " Possible C/C++ prototypes are:\n"
20027  " libbgp::BgpPathAttribMpUnreachNlriUnknow::BgpPathAttribMpUnreachNlriUnknow(libbgp::BgpLogHandler *)\n"
20028  " libbgp::BgpPathAttribMpUnreachNlriUnknow::BgpPathAttribMpUnreachNlriUnknow(libbgp::BgpLogHandler *,uint8_t const *,size_t)\n");
20029  return 0;
20030 }
20031 
20032 
20033 SWIGINTERN PyObject *_wrap_delete_BgpPathAttribMpUnreachNlriUnknow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20034  PyObject *resultobj = 0;
20036  void *argp1 = 0 ;
20037  int res1 = 0 ;
20038  PyObject * obj0 = 0 ;
20039 
20040  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpPathAttribMpUnreachNlriUnknow",&obj0)) SWIG_fail;
20041  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriUnknow, SWIG_POINTER_DISOWN | 0 );
20042  if (!SWIG_IsOK(res1)) {
20043  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpPathAttribMpUnreachNlriUnknow" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriUnknow *""'");
20044  }
20045  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriUnknow * >(argp1);
20046  delete arg1;
20047  resultobj = SWIG_Py_Void();
20048  return resultobj;
20049 fail:
20050  return NULL;
20051 }
20052 
20053 
20054 SWIGINTERN PyObject *_wrap_BgpPathAttribMpUnreachNlriUnknow_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20055  PyObject *resultobj = 0;
20057  void *argp1 = 0 ;
20058  int res1 = 0 ;
20059  PyObject * obj0 = 0 ;
20060  libbgp::BgpPathAttrib *result = 0 ;
20061 
20062  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpUnreachNlriUnknow_clone",&obj0)) SWIG_fail;
20063  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriUnknow, 0 | 0 );
20064  if (!SWIG_IsOK(res1)) {
20065  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpUnreachNlriUnknow_clone" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriUnknow const *""'");
20066  }
20067  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriUnknow * >(argp1);
20068  result = (libbgp::BgpPathAttrib *)((libbgp::BgpPathAttribMpUnreachNlriUnknow const *)arg1)->clone();
20069  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
20070  return resultobj;
20071 fail:
20072  return NULL;
20073 }
20074 
20075 
20076 SWIGINTERN PyObject *_wrap_BgpPathAttribMpUnreachNlriUnknow_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20077  PyObject *resultobj = 0;
20079  uint8_t *arg2 = (uint8_t *) 0 ;
20080  size_t arg3 ;
20081  void *argp1 = 0 ;
20082  int res1 = 0 ;
20083  void *argp2 = 0 ;
20084  int res2 = 0 ;
20085  size_t val3 ;
20086  int ecode3 = 0 ;
20087  PyObject * obj0 = 0 ;
20088  PyObject * obj1 = 0 ;
20089  PyObject * obj2 = 0 ;
20090  ssize_t result;
20091 
20092  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribMpUnreachNlriUnknow_parse",&obj0,&obj1,&obj2)) SWIG_fail;
20093  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriUnknow, 0 | 0 );
20094  if (!SWIG_IsOK(res1)) {
20095  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpUnreachNlriUnknow_parse" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriUnknow *""'");
20096  }
20097  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriUnknow * >(argp1);
20098  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
20099  if (!SWIG_IsOK(res2)) {
20100  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribMpUnreachNlriUnknow_parse" "', argument " "2"" of type '" "uint8_t const *""'");
20101  }
20102  arg2 = reinterpret_cast< uint8_t * >(argp2);
20103  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
20104  if (!SWIG_IsOK(ecode3)) {
20105  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribMpUnreachNlriUnknow_parse" "', argument " "3"" of type '" "size_t""'");
20106  }
20107  arg3 = static_cast< size_t >(val3);
20108  result = (arg1)->parse((uint8_t const *)arg2,arg3);
20109  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
20110  return resultobj;
20111 fail:
20112  return NULL;
20113 }
20114 
20115 
20116 SWIGINTERN PyObject *_wrap_BgpPathAttribMpUnreachNlriUnknow_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20117  PyObject *resultobj = 0;
20119  uint8_t *arg2 = (uint8_t *) 0 ;
20120  size_t arg3 ;
20121  void *argp1 = 0 ;
20122  int res1 = 0 ;
20123  void *argp2 = 0 ;
20124  int res2 = 0 ;
20125  size_t val3 ;
20126  int ecode3 = 0 ;
20127  PyObject * obj0 = 0 ;
20128  PyObject * obj1 = 0 ;
20129  PyObject * obj2 = 0 ;
20130  ssize_t result;
20131 
20132  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpPathAttribMpUnreachNlriUnknow_write",&obj0,&obj1,&obj2)) SWIG_fail;
20133  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriUnknow, 0 | 0 );
20134  if (!SWIG_IsOK(res1)) {
20135  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpUnreachNlriUnknow_write" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriUnknow const *""'");
20136  }
20137  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriUnknow * >(argp1);
20138  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
20139  if (!SWIG_IsOK(res2)) {
20140  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpPathAttribMpUnreachNlriUnknow_write" "', argument " "2"" of type '" "uint8_t *""'");
20141  }
20142  arg2 = reinterpret_cast< uint8_t * >(argp2);
20143  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
20144  if (!SWIG_IsOK(ecode3)) {
20145  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpPathAttribMpUnreachNlriUnknow_write" "', argument " "3"" of type '" "size_t""'");
20146  }
20147  arg3 = static_cast< size_t >(val3);
20148  result = ((libbgp::BgpPathAttribMpUnreachNlriUnknow const *)arg1)->write(arg2,arg3);
20149  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
20150  return resultobj;
20151 fail:
20152  return NULL;
20153 }
20154 
20155 
20156 SWIGINTERN PyObject *_wrap_BgpPathAttribMpUnreachNlriUnknow_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20157  PyObject *resultobj = 0;
20159  size_t arg2 ;
20160  uint8_t **arg3 = (uint8_t **) 0 ;
20161  size_t *arg4 = (size_t *) 0 ;
20162  void *argp1 = 0 ;
20163  int res1 = 0 ;
20164  size_t val2 ;
20165  int ecode2 = 0 ;
20166  void *argp3 = 0 ;
20167  int res3 = 0 ;
20168  void *argp4 = 0 ;
20169  int res4 = 0 ;
20170  PyObject * obj0 = 0 ;
20171  PyObject * obj1 = 0 ;
20172  PyObject * obj2 = 0 ;
20173  PyObject * obj3 = 0 ;
20174  ssize_t result;
20175 
20176  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpPathAttribMpUnreachNlriUnknow_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20177  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriUnknow, 0 | 0 );
20178  if (!SWIG_IsOK(res1)) {
20179  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpUnreachNlriUnknow_doPrint" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriUnknow const *""'");
20180  }
20181  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriUnknow * >(argp1);
20182  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
20183  if (!SWIG_IsOK(ecode2)) {
20184  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpPathAttribMpUnreachNlriUnknow_doPrint" "', argument " "2"" of type '" "size_t""'");
20185  }
20186  arg2 = static_cast< size_t >(val2);
20187  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
20188  if (!SWIG_IsOK(res3)) {
20189  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpPathAttribMpUnreachNlriUnknow_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
20190  }
20191  arg3 = reinterpret_cast< uint8_t ** >(argp3);
20192  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
20193  if (!SWIG_IsOK(res4)) {
20194  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpPathAttribMpUnreachNlriUnknow_doPrint" "', argument " "4"" of type '" "size_t *""'");
20195  }
20196  arg4 = reinterpret_cast< size_t * >(argp4);
20197  result = ((libbgp::BgpPathAttribMpUnreachNlriUnknow const *)arg1)->doPrint(arg2,arg3,arg4);
20198  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
20199  return resultobj;
20200 fail:
20201  return NULL;
20202 }
20203 
20204 
20205 SWIGINTERN PyObject *_wrap_BgpPathAttribMpUnreachNlriUnknow_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20206  PyObject *resultobj = 0;
20208  void *argp1 = 0 ;
20209  int res1 = 0 ;
20210  PyObject * obj0 = 0 ;
20211  ssize_t result;
20212 
20213  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpUnreachNlriUnknow_length",&obj0)) SWIG_fail;
20214  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriUnknow, 0 | 0 );
20215  if (!SWIG_IsOK(res1)) {
20216  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpUnreachNlriUnknow_length" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriUnknow const *""'");
20217  }
20218  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriUnknow * >(argp1);
20219  result = ((libbgp::BgpPathAttribMpUnreachNlriUnknow const *)arg1)->length();
20220  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
20221  return resultobj;
20222 fail:
20223  return NULL;
20224 }
20225 
20226 
20227 SWIGINTERN PyObject *_wrap_BgpPathAttribMpUnreachNlriUnknow_getWithdrawnRoutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20228  PyObject *resultobj = 0;
20230  void *argp1 = 0 ;
20231  int res1 = 0 ;
20232  PyObject * obj0 = 0 ;
20233  uint8_t *result = 0 ;
20234 
20235  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpUnreachNlriUnknow_getWithdrawnRoutes",&obj0)) SWIG_fail;
20236  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriUnknow, 0 | 0 );
20237  if (!SWIG_IsOK(res1)) {
20238  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpUnreachNlriUnknow_getWithdrawnRoutes" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriUnknow const *""'");
20239  }
20240  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriUnknow * >(argp1);
20241  result = (uint8_t *)((libbgp::BgpPathAttribMpUnreachNlriUnknow const *)arg1)->getWithdrawnRoutes();
20242  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
20243  return resultobj;
20244 fail:
20245  return NULL;
20246 }
20247 
20248 
20249 SWIGINTERN PyObject *_wrap_BgpPathAttribMpUnreachNlriUnknow_getWithdrawnRoutesLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20250  PyObject *resultobj = 0;
20252  void *argp1 = 0 ;
20253  int res1 = 0 ;
20254  PyObject * obj0 = 0 ;
20255  size_t result;
20256 
20257  if (!PyArg_ParseTuple(args,(char *)"O:BgpPathAttribMpUnreachNlriUnknow_getWithdrawnRoutesLength",&obj0)) SWIG_fail;
20258  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriUnknow, 0 | 0 );
20259  if (!SWIG_IsOK(res1)) {
20260  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpPathAttribMpUnreachNlriUnknow_getWithdrawnRoutesLength" "', argument " "1"" of type '" "libbgp::BgpPathAttribMpUnreachNlriUnknow const *""'");
20261  }
20262  arg1 = reinterpret_cast< libbgp::BgpPathAttribMpUnreachNlriUnknow * >(argp1);
20263  result = ((libbgp::BgpPathAttribMpUnreachNlriUnknow const *)arg1)->getWithdrawnRoutesLength();
20264  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20265  return resultobj;
20266 fail:
20267  return NULL;
20268 }
20269 
20270 
20271 SWIGINTERN PyObject *BgpPathAttribMpUnreachNlriUnknow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20272  PyObject *obj;
20273  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
20274  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpPathAttribMpUnreachNlriUnknow, SWIG_NewClientData(obj));
20275  return SWIG_Py_Void();
20276 }
20277 
20278 SWIGINTERN PyObject *_wrap_Rib6Entry_src_router_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20279  PyObject *resultobj = 0;
20281  uint32_t arg2 ;
20282  void *argp1 = 0 ;
20283  int res1 = 0 ;
20284  unsigned int val2 ;
20285  int ecode2 = 0 ;
20286  PyObject * obj0 = 0 ;
20287  PyObject * obj1 = 0 ;
20288 
20289  if (!PyArg_ParseTuple(args,(char *)"OO:Rib6Entry_src_router_id_set",&obj0,&obj1)) SWIG_fail;
20290  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t, 0 | 0 );
20291  if (!SWIG_IsOK(res1)) {
20292  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib6Entry_src_router_id_set" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib6Entry > *""'");
20293  }
20294  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib6Entry > * >(argp1);
20295  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
20296  if (!SWIG_IsOK(ecode2)) {
20297  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rib6Entry_src_router_id_set" "', argument " "2"" of type '" "uint32_t""'");
20298  }
20299  arg2 = static_cast< uint32_t >(val2);
20300  if (arg1) (arg1)->src_router_id = arg2;
20301  resultobj = SWIG_Py_Void();
20302  return resultobj;
20303 fail:
20304  return NULL;
20305 }
20306 
20307 
20308 SWIGINTERN PyObject *_wrap_Rib6Entry_src_router_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20309  PyObject *resultobj = 0;
20311  void *argp1 = 0 ;
20312  int res1 = 0 ;
20313  PyObject * obj0 = 0 ;
20314  uint32_t result;
20315 
20316  if (!PyArg_ParseTuple(args,(char *)"O:Rib6Entry_src_router_id_get",&obj0)) SWIG_fail;
20317  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t, 0 | 0 );
20318  if (!SWIG_IsOK(res1)) {
20319  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib6Entry_src_router_id_get" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib6Entry > *""'");
20320  }
20321  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib6Entry > * >(argp1);
20322  result = (uint32_t) ((arg1)->src_router_id);
20323  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
20324  return resultobj;
20325 fail:
20326  return NULL;
20327 }
20328 
20329 
20330 SWIGINTERN PyObject *_wrap_Rib6Entry_update_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20331  PyObject *resultobj = 0;
20333  uint64_t arg2 ;
20334  void *argp1 = 0 ;
20335  int res1 = 0 ;
20336  unsigned long long val2 ;
20337  int ecode2 = 0 ;
20338  PyObject * obj0 = 0 ;
20339  PyObject * obj1 = 0 ;
20340 
20341  if (!PyArg_ParseTuple(args,(char *)"OO:Rib6Entry_update_id_set",&obj0,&obj1)) SWIG_fail;
20342  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t, 0 | 0 );
20343  if (!SWIG_IsOK(res1)) {
20344  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib6Entry_update_id_set" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib6Entry > *""'");
20345  }
20346  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib6Entry > * >(argp1);
20347  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
20348  if (!SWIG_IsOK(ecode2)) {
20349  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rib6Entry_update_id_set" "', argument " "2"" of type '" "uint64_t""'");
20350  }
20351  arg2 = static_cast< uint64_t >(val2);
20352  if (arg1) (arg1)->update_id = arg2;
20353  resultobj = SWIG_Py_Void();
20354  return resultobj;
20355 fail:
20356  return NULL;
20357 }
20358 
20359 
20360 SWIGINTERN PyObject *_wrap_Rib6Entry_update_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20361  PyObject *resultobj = 0;
20363  void *argp1 = 0 ;
20364  int res1 = 0 ;
20365  PyObject * obj0 = 0 ;
20366  uint64_t result;
20367 
20368  if (!PyArg_ParseTuple(args,(char *)"O:Rib6Entry_update_id_get",&obj0)) SWIG_fail;
20369  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t, 0 | 0 );
20370  if (!SWIG_IsOK(res1)) {
20371  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib6Entry_update_id_get" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib6Entry > *""'");
20372  }
20373  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib6Entry > * >(argp1);
20374  result = (uint64_t) ((arg1)->update_id);
20375  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
20376  return resultobj;
20377 fail:
20378  return NULL;
20379 }
20380 
20381 
20382 SWIGINTERN PyObject *_wrap_Rib6Entry_weight_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20383  PyObject *resultobj = 0;
20385  int32_t arg2 ;
20386  void *argp1 = 0 ;
20387  int res1 = 0 ;
20388  int val2 ;
20389  int ecode2 = 0 ;
20390  PyObject * obj0 = 0 ;
20391  PyObject * obj1 = 0 ;
20392 
20393  if (!PyArg_ParseTuple(args,(char *)"OO:Rib6Entry_weight_set",&obj0,&obj1)) SWIG_fail;
20394  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t, 0 | 0 );
20395  if (!SWIG_IsOK(res1)) {
20396  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib6Entry_weight_set" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib6Entry > *""'");
20397  }
20398  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib6Entry > * >(argp1);
20399  ecode2 = SWIG_AsVal_int(obj1, &val2);
20400  if (!SWIG_IsOK(ecode2)) {
20401  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rib6Entry_weight_set" "', argument " "2"" of type '" "int32_t""'");
20402  }
20403  arg2 = static_cast< int32_t >(val2);
20404  if (arg1) (arg1)->weight = arg2;
20405  resultobj = SWIG_Py_Void();
20406  return resultobj;
20407 fail:
20408  return NULL;
20409 }
20410 
20411 
20412 SWIGINTERN PyObject *_wrap_Rib6Entry_weight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20413  PyObject *resultobj = 0;
20415  void *argp1 = 0 ;
20416  int res1 = 0 ;
20417  PyObject * obj0 = 0 ;
20418  int32_t result;
20419 
20420  if (!PyArg_ParseTuple(args,(char *)"O:Rib6Entry_weight_get",&obj0)) SWIG_fail;
20421  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t, 0 | 0 );
20422  if (!SWIG_IsOK(res1)) {
20423  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib6Entry_weight_get" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib6Entry > *""'");
20424  }
20425  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib6Entry > * >(argp1);
20426  result = (int32_t) ((arg1)->weight);
20427  resultobj = SWIG_From_int(static_cast< int >(result));
20428  return resultobj;
20429 fail:
20430  return NULL;
20431 }
20432 
20433 
20434 SWIGINTERN PyObject *_wrap_Rib6Entry_attribs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20435  PyObject *resultobj = 0;
20437  std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *arg2 = (std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *) 0 ;
20438  void *argp1 = 0 ;
20439  int res1 = 0 ;
20440  void *argp2 = 0 ;
20441  int res2 = 0 ;
20442  PyObject * obj0 = 0 ;
20443  PyObject * obj1 = 0 ;
20444 
20445  if (!PyArg_ParseTuple(args,(char *)"OO:Rib6Entry_attribs_set",&obj0,&obj1)) SWIG_fail;
20446  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t, 0 | 0 );
20447  if (!SWIG_IsOK(res1)) {
20448  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib6Entry_attribs_set" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib6Entry > *""'");
20449  }
20450  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib6Entry > * >(argp1);
20451  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0 | 0 );
20452  if (!SWIG_IsOK(res2)) {
20453  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rib6Entry_attribs_set" "', argument " "2"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *""'");
20454  }
20455  arg2 = reinterpret_cast< std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > * >(argp2);
20456  if (arg1) (arg1)->attribs = *arg2;
20457  resultobj = SWIG_Py_Void();
20458  return resultobj;
20459 fail:
20460  return NULL;
20461 }
20462 
20463 
20464 SWIGINTERN PyObject *_wrap_Rib6Entry_attribs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20465  PyObject *resultobj = 0;
20467  void *argp1 = 0 ;
20468  int res1 = 0 ;
20469  PyObject * obj0 = 0 ;
20470  std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *result = 0 ;
20471 
20472  if (!PyArg_ParseTuple(args,(char *)"O:Rib6Entry_attribs_get",&obj0)) SWIG_fail;
20473  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t, 0 | 0 );
20474  if (!SWIG_IsOK(res1)) {
20475  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib6Entry_attribs_get" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib6Entry > *""'");
20476  }
20477  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib6Entry > * >(argp1);
20478  result = (std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *)& ((arg1)->attribs);
20479  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0 | 0 );
20480  return resultobj;
20481 fail:
20482  return NULL;
20483 }
20484 
20485 
20486 SWIGINTERN PyObject *_wrap_Rib6Entry___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20487  PyObject *resultobj = 0;
20489  libbgp::BgpRib6Entry *arg2 = 0 ;
20490  void *argp1 = 0 ;
20491  int res1 = 0 ;
20492  void *argp2 = 0 ;
20493  int res2 = 0 ;
20494  PyObject * obj0 = 0 ;
20495  PyObject * obj1 = 0 ;
20496  bool result;
20497 
20498  if (!PyArg_ParseTuple(args,(char *)"OO:Rib6Entry___gt__",&obj0,&obj1)) SWIG_fail;
20499  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t, 0 | 0 );
20500  if (!SWIG_IsOK(res1)) {
20501  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib6Entry___gt__" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib6Entry > const *""'");
20502  }
20503  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib6Entry > * >(argp1);
20504  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__BgpRib6Entry, 0 | 0);
20505  if (!SWIG_IsOK(res2)) {
20506  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rib6Entry___gt__" "', argument " "2"" of type '" "libbgp::BgpRib6Entry const &""'");
20507  }
20508  if (!argp2) {
20509  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rib6Entry___gt__" "', argument " "2"" of type '" "libbgp::BgpRib6Entry const &""'");
20510  }
20511  arg2 = reinterpret_cast< libbgp::BgpRib6Entry * >(argp2);
20512  result = (bool)((libbgp::BgpRibEntry< libbgp::BgpRib6Entry > const *)arg1)->operator >((libbgp::BgpRib6Entry const &)*arg2);
20513  resultobj = SWIG_From_bool(static_cast< bool >(result));
20514  return resultobj;
20515 fail:
20516  return NULL;
20517 }
20518 
20519 
20520 SWIGINTERN PyObject *_wrap_new_Rib6Entry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20521  PyObject *resultobj = 0;
20523 
20524  if (!PyArg_ParseTuple(args,(char *)":new_Rib6Entry")) SWIG_fail;
20526  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t, SWIG_POINTER_NEW | 0 );
20527  return resultobj;
20528 fail:
20529  return NULL;
20530 }
20531 
20532 
20533 SWIGINTERN PyObject *_wrap_delete_Rib6Entry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20534  PyObject *resultobj = 0;
20536  void *argp1 = 0 ;
20537  int res1 = 0 ;
20538  PyObject * obj0 = 0 ;
20539 
20540  if (!PyArg_ParseTuple(args,(char *)"O:delete_Rib6Entry",&obj0)) SWIG_fail;
20541  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t, SWIG_POINTER_DISOWN | 0 );
20542  if (!SWIG_IsOK(res1)) {
20543  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rib6Entry" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib6Entry > *""'");
20544  }
20545  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib6Entry > * >(argp1);
20546  delete arg1;
20547  resultobj = SWIG_Py_Void();
20548  return resultobj;
20549 fail:
20550  return NULL;
20551 }
20552 
20553 
20554 SWIGINTERN PyObject *Rib6Entry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20555  PyObject *obj;
20556  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
20557  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t, SWIG_NewClientData(obj));
20558  return SWIG_Py_Void();
20559 }
20560 
20561 SWIGINTERN PyObject *_wrap_Rib4Entry_src_router_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20562  PyObject *resultobj = 0;
20564  uint32_t arg2 ;
20565  void *argp1 = 0 ;
20566  int res1 = 0 ;
20567  unsigned int val2 ;
20568  int ecode2 = 0 ;
20569  PyObject * obj0 = 0 ;
20570  PyObject * obj1 = 0 ;
20571 
20572  if (!PyArg_ParseTuple(args,(char *)"OO:Rib4Entry_src_router_id_set",&obj0,&obj1)) SWIG_fail;
20573  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t, 0 | 0 );
20574  if (!SWIG_IsOK(res1)) {
20575  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib4Entry_src_router_id_set" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib4Entry > *""'");
20576  }
20577  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib4Entry > * >(argp1);
20578  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
20579  if (!SWIG_IsOK(ecode2)) {
20580  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rib4Entry_src_router_id_set" "', argument " "2"" of type '" "uint32_t""'");
20581  }
20582  arg2 = static_cast< uint32_t >(val2);
20583  if (arg1) (arg1)->src_router_id = arg2;
20584  resultobj = SWIG_Py_Void();
20585  return resultobj;
20586 fail:
20587  return NULL;
20588 }
20589 
20590 
20591 SWIGINTERN PyObject *_wrap_Rib4Entry_src_router_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20592  PyObject *resultobj = 0;
20594  void *argp1 = 0 ;
20595  int res1 = 0 ;
20596  PyObject * obj0 = 0 ;
20597  uint32_t result;
20598 
20599  if (!PyArg_ParseTuple(args,(char *)"O:Rib4Entry_src_router_id_get",&obj0)) SWIG_fail;
20600  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t, 0 | 0 );
20601  if (!SWIG_IsOK(res1)) {
20602  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib4Entry_src_router_id_get" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib4Entry > *""'");
20603  }
20604  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib4Entry > * >(argp1);
20605  result = (uint32_t) ((arg1)->src_router_id);
20606  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
20607  return resultobj;
20608 fail:
20609  return NULL;
20610 }
20611 
20612 
20613 SWIGINTERN PyObject *_wrap_Rib4Entry_update_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20614  PyObject *resultobj = 0;
20616  uint64_t arg2 ;
20617  void *argp1 = 0 ;
20618  int res1 = 0 ;
20619  unsigned long long val2 ;
20620  int ecode2 = 0 ;
20621  PyObject * obj0 = 0 ;
20622  PyObject * obj1 = 0 ;
20623 
20624  if (!PyArg_ParseTuple(args,(char *)"OO:Rib4Entry_update_id_set",&obj0,&obj1)) SWIG_fail;
20625  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t, 0 | 0 );
20626  if (!SWIG_IsOK(res1)) {
20627  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib4Entry_update_id_set" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib4Entry > *""'");
20628  }
20629  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib4Entry > * >(argp1);
20630  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
20631  if (!SWIG_IsOK(ecode2)) {
20632  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rib4Entry_update_id_set" "', argument " "2"" of type '" "uint64_t""'");
20633  }
20634  arg2 = static_cast< uint64_t >(val2);
20635  if (arg1) (arg1)->update_id = arg2;
20636  resultobj = SWIG_Py_Void();
20637  return resultobj;
20638 fail:
20639  return NULL;
20640 }
20641 
20642 
20643 SWIGINTERN PyObject *_wrap_Rib4Entry_update_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20644  PyObject *resultobj = 0;
20646  void *argp1 = 0 ;
20647  int res1 = 0 ;
20648  PyObject * obj0 = 0 ;
20649  uint64_t result;
20650 
20651  if (!PyArg_ParseTuple(args,(char *)"O:Rib4Entry_update_id_get",&obj0)) SWIG_fail;
20652  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t, 0 | 0 );
20653  if (!SWIG_IsOK(res1)) {
20654  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib4Entry_update_id_get" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib4Entry > *""'");
20655  }
20656  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib4Entry > * >(argp1);
20657  result = (uint64_t) ((arg1)->update_id);
20658  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
20659  return resultobj;
20660 fail:
20661  return NULL;
20662 }
20663 
20664 
20665 SWIGINTERN PyObject *_wrap_Rib4Entry_weight_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20666  PyObject *resultobj = 0;
20668  int32_t arg2 ;
20669  void *argp1 = 0 ;
20670  int res1 = 0 ;
20671  int val2 ;
20672  int ecode2 = 0 ;
20673  PyObject * obj0 = 0 ;
20674  PyObject * obj1 = 0 ;
20675 
20676  if (!PyArg_ParseTuple(args,(char *)"OO:Rib4Entry_weight_set",&obj0,&obj1)) SWIG_fail;
20677  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t, 0 | 0 );
20678  if (!SWIG_IsOK(res1)) {
20679  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib4Entry_weight_set" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib4Entry > *""'");
20680  }
20681  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib4Entry > * >(argp1);
20682  ecode2 = SWIG_AsVal_int(obj1, &val2);
20683  if (!SWIG_IsOK(ecode2)) {
20684  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rib4Entry_weight_set" "', argument " "2"" of type '" "int32_t""'");
20685  }
20686  arg2 = static_cast< int32_t >(val2);
20687  if (arg1) (arg1)->weight = arg2;
20688  resultobj = SWIG_Py_Void();
20689  return resultobj;
20690 fail:
20691  return NULL;
20692 }
20693 
20694 
20695 SWIGINTERN PyObject *_wrap_Rib4Entry_weight_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20696  PyObject *resultobj = 0;
20698  void *argp1 = 0 ;
20699  int res1 = 0 ;
20700  PyObject * obj0 = 0 ;
20701  int32_t result;
20702 
20703  if (!PyArg_ParseTuple(args,(char *)"O:Rib4Entry_weight_get",&obj0)) SWIG_fail;
20704  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t, 0 | 0 );
20705  if (!SWIG_IsOK(res1)) {
20706  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib4Entry_weight_get" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib4Entry > *""'");
20707  }
20708  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib4Entry > * >(argp1);
20709  result = (int32_t) ((arg1)->weight);
20710  resultobj = SWIG_From_int(static_cast< int >(result));
20711  return resultobj;
20712 fail:
20713  return NULL;
20714 }
20715 
20716 
20717 SWIGINTERN PyObject *_wrap_Rib4Entry_attribs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20718  PyObject *resultobj = 0;
20720  std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *arg2 = (std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *) 0 ;
20721  void *argp1 = 0 ;
20722  int res1 = 0 ;
20723  void *argp2 = 0 ;
20724  int res2 = 0 ;
20725  PyObject * obj0 = 0 ;
20726  PyObject * obj1 = 0 ;
20727 
20728  if (!PyArg_ParseTuple(args,(char *)"OO:Rib4Entry_attribs_set",&obj0,&obj1)) SWIG_fail;
20729  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t, 0 | 0 );
20730  if (!SWIG_IsOK(res1)) {
20731  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib4Entry_attribs_set" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib4Entry > *""'");
20732  }
20733  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib4Entry > * >(argp1);
20734  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0 | 0 );
20735  if (!SWIG_IsOK(res2)) {
20736  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rib4Entry_attribs_set" "', argument " "2"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *""'");
20737  }
20738  arg2 = reinterpret_cast< std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > * >(argp2);
20739  if (arg1) (arg1)->attribs = *arg2;
20740  resultobj = SWIG_Py_Void();
20741  return resultobj;
20742 fail:
20743  return NULL;
20744 }
20745 
20746 
20747 SWIGINTERN PyObject *_wrap_Rib4Entry_attribs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20748  PyObject *resultobj = 0;
20750  void *argp1 = 0 ;
20751  int res1 = 0 ;
20752  PyObject * obj0 = 0 ;
20753  std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *result = 0 ;
20754 
20755  if (!PyArg_ParseTuple(args,(char *)"O:Rib4Entry_attribs_get",&obj0)) SWIG_fail;
20756  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t, 0 | 0 );
20757  if (!SWIG_IsOK(res1)) {
20758  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib4Entry_attribs_get" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib4Entry > *""'");
20759  }
20760  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib4Entry > * >(argp1);
20761  result = (std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *)& ((arg1)->attribs);
20762  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0 | 0 );
20763  return resultobj;
20764 fail:
20765  return NULL;
20766 }
20767 
20768 
20769 SWIGINTERN PyObject *_wrap_Rib4Entry___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20770  PyObject *resultobj = 0;
20772  libbgp::BgpRib4Entry *arg2 = 0 ;
20773  void *argp1 = 0 ;
20774  int res1 = 0 ;
20775  void *argp2 = 0 ;
20776  int res2 = 0 ;
20777  PyObject * obj0 = 0 ;
20778  PyObject * obj1 = 0 ;
20779  bool result;
20780 
20781  if (!PyArg_ParseTuple(args,(char *)"OO:Rib4Entry___gt__",&obj0,&obj1)) SWIG_fail;
20782  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t, 0 | 0 );
20783  if (!SWIG_IsOK(res1)) {
20784  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rib4Entry___gt__" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib4Entry > const *""'");
20785  }
20786  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib4Entry > * >(argp1);
20787  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__BgpRib4Entry, 0 | 0);
20788  if (!SWIG_IsOK(res2)) {
20789  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rib4Entry___gt__" "', argument " "2"" of type '" "libbgp::BgpRib4Entry const &""'");
20790  }
20791  if (!argp2) {
20792  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rib4Entry___gt__" "', argument " "2"" of type '" "libbgp::BgpRib4Entry const &""'");
20793  }
20794  arg2 = reinterpret_cast< libbgp::BgpRib4Entry * >(argp2);
20795  result = (bool)((libbgp::BgpRibEntry< libbgp::BgpRib4Entry > const *)arg1)->operator >((libbgp::BgpRib4Entry const &)*arg2);
20796  resultobj = SWIG_From_bool(static_cast< bool >(result));
20797  return resultobj;
20798 fail:
20799  return NULL;
20800 }
20801 
20802 
20803 SWIGINTERN PyObject *_wrap_new_Rib4Entry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20804  PyObject *resultobj = 0;
20806 
20807  if (!PyArg_ParseTuple(args,(char *)":new_Rib4Entry")) SWIG_fail;
20809  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t, SWIG_POINTER_NEW | 0 );
20810  return resultobj;
20811 fail:
20812  return NULL;
20813 }
20814 
20815 
20816 SWIGINTERN PyObject *_wrap_delete_Rib4Entry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20817  PyObject *resultobj = 0;
20819  void *argp1 = 0 ;
20820  int res1 = 0 ;
20821  PyObject * obj0 = 0 ;
20822 
20823  if (!PyArg_ParseTuple(args,(char *)"O:delete_Rib4Entry",&obj0)) SWIG_fail;
20824  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t, SWIG_POINTER_DISOWN | 0 );
20825  if (!SWIG_IsOK(res1)) {
20826  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rib4Entry" "', argument " "1"" of type '" "libbgp::BgpRibEntry< libbgp::BgpRib4Entry > *""'");
20827  }
20828  arg1 = reinterpret_cast< libbgp::BgpRibEntry< libbgp::BgpRib4Entry > * >(argp1);
20829  delete arg1;
20830  resultobj = SWIG_Py_Void();
20831  return resultobj;
20832 fail:
20833  return NULL;
20834 }
20835 
20836 
20837 SWIGINTERN PyObject *Rib4Entry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20838  PyObject *obj;
20839  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
20840  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t, SWIG_NewClientData(obj));
20841  return SWIG_Py_Void();
20842 }
20843 
20844 SWIGINTERN PyObject *_wrap_new_BgpRib4Entry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20845  PyObject *resultobj = 0;
20846  libbgp::Prefix4 arg1 ;
20847  uint32_t arg2 ;
20848  SwigValueWrapper< std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > > arg3 ;
20849  void *argp1 ;
20850  int res1 = 0 ;
20851  unsigned int val2 ;
20852  int ecode2 = 0 ;
20853  void *argp3 ;
20854  int res3 = 0 ;
20855  PyObject * obj0 = 0 ;
20856  PyObject * obj1 = 0 ;
20857  PyObject * obj2 = 0 ;
20858  libbgp::BgpRib4Entry *result = 0 ;
20859 
20860  if (!PyArg_ParseTuple(args,(char *)"OOO:new_BgpRib4Entry",&obj0,&obj1,&obj2)) SWIG_fail;
20861  {
20862  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_libbgp__Prefix4, 0 | 0);
20863  if (!SWIG_IsOK(res1)) {
20864  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpRib4Entry" "', argument " "1"" of type '" "libbgp::Prefix4""'");
20865  }
20866  if (!argp1) {
20867  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BgpRib4Entry" "', argument " "1"" of type '" "libbgp::Prefix4""'");
20868  } else {
20869  libbgp::Prefix4 * temp = reinterpret_cast< libbgp::Prefix4 * >(argp1);
20870  arg1 = *temp;
20871  if (SWIG_IsNewObj(res1)) delete temp;
20872  }
20873  }
20874  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
20875  if (!SWIG_IsOK(ecode2)) {
20876  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpRib4Entry" "', argument " "2"" of type '" "uint32_t""'");
20877  }
20878  arg2 = static_cast< uint32_t >(val2);
20879  {
20880  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0 | 0);
20881  if (!SWIG_IsOK(res3)) {
20882  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BgpRib4Entry" "', argument " "3"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const""'");
20883  }
20884  if (!argp3) {
20885  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BgpRib4Entry" "', argument " "3"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const""'");
20886  } else {
20887  std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > * temp = reinterpret_cast< std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > * >(argp3);
20888  arg3 = *temp;
20889  if (SWIG_IsNewObj(res3)) delete temp;
20890  }
20891  }
20892  result = (libbgp::BgpRib4Entry *)new libbgp::BgpRib4Entry(arg1,arg2,arg3);
20893  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib4Entry, SWIG_POINTER_NEW | 0 );
20894  return resultobj;
20895 fail:
20896  return NULL;
20897 }
20898 
20899 
20900 SWIGINTERN PyObject *_wrap_BgpRib4Entry_route_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20901  PyObject *resultobj = 0;
20903  libbgp::Prefix4 *arg2 = (libbgp::Prefix4 *) 0 ;
20904  void *argp1 = 0 ;
20905  int res1 = 0 ;
20906  void *argp2 = 0 ;
20907  int res2 = 0 ;
20908  PyObject * obj0 = 0 ;
20909  PyObject * obj1 = 0 ;
20910 
20911  if (!PyArg_ParseTuple(args,(char *)"OO:BgpRib4Entry_route_set",&obj0,&obj1)) SWIG_fail;
20912  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4Entry, 0 | 0 );
20913  if (!SWIG_IsOK(res1)) {
20914  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4Entry_route_set" "', argument " "1"" of type '" "libbgp::BgpRib4Entry *""'");
20915  }
20916  arg1 = reinterpret_cast< libbgp::BgpRib4Entry * >(argp1);
20917  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
20918  if (!SWIG_IsOK(res2)) {
20919  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib4Entry_route_set" "', argument " "2"" of type '" "libbgp::Prefix4 *""'");
20920  }
20921  arg2 = reinterpret_cast< libbgp::Prefix4 * >(argp2);
20922  if (arg1) (arg1)->route = *arg2;
20923  resultobj = SWIG_Py_Void();
20924  return resultobj;
20925 fail:
20926  return NULL;
20927 }
20928 
20929 
20930 SWIGINTERN PyObject *_wrap_BgpRib4Entry_route_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20931  PyObject *resultobj = 0;
20933  void *argp1 = 0 ;
20934  int res1 = 0 ;
20935  PyObject * obj0 = 0 ;
20936  libbgp::Prefix4 *result = 0 ;
20937 
20938  if (!PyArg_ParseTuple(args,(char *)"O:BgpRib4Entry_route_get",&obj0)) SWIG_fail;
20939  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4Entry, 0 | 0 );
20940  if (!SWIG_IsOK(res1)) {
20941  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4Entry_route_get" "', argument " "1"" of type '" "libbgp::BgpRib4Entry *""'");
20942  }
20943  arg1 = reinterpret_cast< libbgp::BgpRib4Entry * >(argp1);
20944  result = (libbgp::Prefix4 *)& ((arg1)->route);
20945  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Prefix4, 0 | 0 );
20946  return resultobj;
20947 fail:
20948  return NULL;
20949 }
20950 
20951 
20952 SWIGINTERN PyObject *_wrap_BgpRib4Entry_getNexthop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20953  PyObject *resultobj = 0;
20955  void *argp1 = 0 ;
20956  int res1 = 0 ;
20957  PyObject * obj0 = 0 ;
20958  uint32_t result;
20959 
20960  if (!PyArg_ParseTuple(args,(char *)"O:BgpRib4Entry_getNexthop",&obj0)) SWIG_fail;
20961  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4Entry, 0 | 0 );
20962  if (!SWIG_IsOK(res1)) {
20963  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4Entry_getNexthop" "', argument " "1"" of type '" "libbgp::BgpRib4Entry const *""'");
20964  }
20965  arg1 = reinterpret_cast< libbgp::BgpRib4Entry * >(argp1);
20966  result = (uint32_t)((libbgp::BgpRib4Entry const *)arg1)->getNexthop();
20967  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
20968  return resultobj;
20969 fail:
20970  return NULL;
20971 }
20972 
20973 
20974 SWIGINTERN PyObject *_wrap_delete_BgpRib4Entry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20975  PyObject *resultobj = 0;
20977  void *argp1 = 0 ;
20978  int res1 = 0 ;
20979  PyObject * obj0 = 0 ;
20980 
20981  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpRib4Entry",&obj0)) SWIG_fail;
20982  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4Entry, SWIG_POINTER_DISOWN | 0 );
20983  if (!SWIG_IsOK(res1)) {
20984  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpRib4Entry" "', argument " "1"" of type '" "libbgp::BgpRib4Entry *""'");
20985  }
20986  arg1 = reinterpret_cast< libbgp::BgpRib4Entry * >(argp1);
20987  delete arg1;
20988  resultobj = SWIG_Py_Void();
20989  return resultobj;
20990 fail:
20991  return NULL;
20992 }
20993 
20994 
20995 SWIGINTERN PyObject *BgpRib4Entry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20996  PyObject *obj;
20997  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
20998  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpRib4Entry, SWIG_NewClientData(obj));
20999  return SWIG_Py_Void();
21000 }
21001 
21002 SWIGINTERN PyObject *_wrap_new_BgpRib4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21003  PyObject *resultobj = 0;
21005  void *argp1 = 0 ;
21006  int res1 = 0 ;
21007  PyObject * obj0 = 0 ;
21008  libbgp::BgpRib4 *result = 0 ;
21009 
21010  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpRib4",&obj0)) SWIG_fail;
21011  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
21012  if (!SWIG_IsOK(res1)) {
21013  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpRib4" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
21014  }
21015  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
21016  result = (libbgp::BgpRib4 *)new libbgp::BgpRib4(arg1);
21017  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib4, SWIG_POINTER_NEW | 0 );
21018  return resultobj;
21019 fail:
21020  return NULL;
21021 }
21022 
21023 
21024 SWIGINTERN PyObject *_wrap_BgpRib4_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21025  PyObject *resultobj = 0;
21026  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
21028  libbgp::Prefix4 *arg3 = 0 ;
21029  uint32_t arg4 ;
21030  int32_t arg5 ;
21031  void *argp1 = 0 ;
21032  int res1 = 0 ;
21033  void *argp2 = 0 ;
21034  int res2 = 0 ;
21035  void *argp3 = 0 ;
21036  int res3 = 0 ;
21037  unsigned int val4 ;
21038  int ecode4 = 0 ;
21039  int val5 ;
21040  int ecode5 = 0 ;
21041  PyObject * obj0 = 0 ;
21042  PyObject * obj1 = 0 ;
21043  PyObject * obj2 = 0 ;
21044  PyObject * obj3 = 0 ;
21045  PyObject * obj4 = 0 ;
21046  libbgp::BgpRib4Entry *result = 0 ;
21047 
21048  if (!PyArg_ParseTuple(args,(char *)"OOOOO:BgpRib4_insert",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21049  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
21050  if (!SWIG_IsOK(res1)) {
21051  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_insert" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
21052  }
21053  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
21054  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
21055  if (!SWIG_IsOK(res2)) {
21056  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib4_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
21057  }
21058  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
21059  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix4, 0 | 0);
21060  if (!SWIG_IsOK(res3)) {
21061  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
21062  }
21063  if (!argp3) {
21064  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
21065  }
21066  arg3 = reinterpret_cast< libbgp::Prefix4 * >(argp3);
21067  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
21068  if (!SWIG_IsOK(ecode4)) {
21069  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BgpRib4_insert" "', argument " "4"" of type '" "uint32_t""'");
21070  }
21071  arg4 = static_cast< uint32_t >(val4);
21072  ecode5 = SWIG_AsVal_int(obj4, &val5);
21073  if (!SWIG_IsOK(ecode5)) {
21074  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BgpRib4_insert" "', argument " "5"" of type '" "int32_t""'");
21075  }
21076  arg5 = static_cast< int32_t >(val5);
21077  result = (libbgp::BgpRib4Entry *)(arg1)->insert(arg2,(libbgp::Prefix4 const &)*arg3,arg4,arg5);
21078  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib4Entry, 0 | 0 );
21079  return resultobj;
21080 fail:
21081  return NULL;
21082 }
21083 
21084 
21085 SWIGINTERN PyObject *_wrap_BgpRib4_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21086  PyObject *resultobj = 0;
21087  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
21089  libbgp::Prefix4 *arg3 = 0 ;
21090  uint32_t arg4 ;
21091  void *argp1 = 0 ;
21092  int res1 = 0 ;
21093  void *argp2 = 0 ;
21094  int res2 = 0 ;
21095  void *argp3 = 0 ;
21096  int res3 = 0 ;
21097  unsigned int val4 ;
21098  int ecode4 = 0 ;
21099  PyObject * obj0 = 0 ;
21100  PyObject * obj1 = 0 ;
21101  PyObject * obj2 = 0 ;
21102  PyObject * obj3 = 0 ;
21103  libbgp::BgpRib4Entry *result = 0 ;
21104 
21105  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpRib4_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21106  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
21107  if (!SWIG_IsOK(res1)) {
21108  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_insert" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
21109  }
21110  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
21111  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
21112  if (!SWIG_IsOK(res2)) {
21113  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib4_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
21114  }
21115  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
21116  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix4, 0 | 0);
21117  if (!SWIG_IsOK(res3)) {
21118  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
21119  }
21120  if (!argp3) {
21121  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
21122  }
21123  arg3 = reinterpret_cast< libbgp::Prefix4 * >(argp3);
21124  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
21125  if (!SWIG_IsOK(ecode4)) {
21126  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BgpRib4_insert" "', argument " "4"" of type '" "uint32_t""'");
21127  }
21128  arg4 = static_cast< uint32_t >(val4);
21129  result = (libbgp::BgpRib4Entry *)(arg1)->insert(arg2,(libbgp::Prefix4 const &)*arg3,arg4);
21130  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib4Entry, 0 | 0 );
21131  return resultobj;
21132 fail:
21133  return NULL;
21134 }
21135 
21136 
21137 SWIGINTERN PyObject *_wrap_BgpRib4_insert__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21138  PyObject *resultobj = 0;
21139  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
21141  libbgp::Prefix4 *arg3 = 0 ;
21142  uint32_t arg4 ;
21144  int32_t arg6 ;
21145  void *argp1 = 0 ;
21146  int res1 = 0 ;
21147  void *argp2 = 0 ;
21148  int res2 = 0 ;
21149  void *argp3 = 0 ;
21150  int res3 = 0 ;
21151  unsigned int val4 ;
21152  int ecode4 = 0 ;
21153  void *argp5 = 0 ;
21154  int res5 = 0 ;
21155  int val6 ;
21156  int ecode6 = 0 ;
21157  PyObject * obj0 = 0 ;
21158  PyObject * obj1 = 0 ;
21159  PyObject * obj2 = 0 ;
21160  PyObject * obj3 = 0 ;
21161  PyObject * obj4 = 0 ;
21162  PyObject * obj5 = 0 ;
21163  libbgp::BgpRib4Entry *result = 0 ;
21164 
21165  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BgpRib4_insert",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
21166  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
21167  if (!SWIG_IsOK(res1)) {
21168  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_insert" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
21169  }
21170  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
21171  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
21172  if (!SWIG_IsOK(res2)) {
21173  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib4_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
21174  }
21175  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
21176  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix4, 0 | 0);
21177  if (!SWIG_IsOK(res3)) {
21178  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
21179  }
21180  if (!argp3) {
21181  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
21182  }
21183  arg3 = reinterpret_cast< libbgp::Prefix4 * >(argp3);
21184  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
21185  if (!SWIG_IsOK(ecode4)) {
21186  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BgpRib4_insert" "', argument " "4"" of type '" "uint32_t""'");
21187  }
21188  arg4 = static_cast< uint32_t >(val4);
21189  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_libbgp__RouteEventBus, 0 | 0 );
21190  if (!SWIG_IsOK(res5)) {
21191  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BgpRib4_insert" "', argument " "5"" of type '" "libbgp::RouteEventBus *""'");
21192  }
21193  arg5 = reinterpret_cast< libbgp::RouteEventBus * >(argp5);
21194  ecode6 = SWIG_AsVal_int(obj5, &val6);
21195  if (!SWIG_IsOK(ecode6)) {
21196  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BgpRib4_insert" "', argument " "6"" of type '" "int32_t""'");
21197  }
21198  arg6 = static_cast< int32_t >(val6);
21199  result = (libbgp::BgpRib4Entry *)(arg1)->insert(arg2,(libbgp::Prefix4 const &)*arg3,arg4,arg5,arg6);
21200  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib4Entry, 0 | 0 );
21201  return resultobj;
21202 fail:
21203  return NULL;
21204 }
21205 
21206 
21207 SWIGINTERN PyObject *_wrap_BgpRib4_insert__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21208  PyObject *resultobj = 0;
21209  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
21211  libbgp::Prefix4 *arg3 = 0 ;
21212  uint32_t arg4 ;
21214  void *argp1 = 0 ;
21215  int res1 = 0 ;
21216  void *argp2 = 0 ;
21217  int res2 = 0 ;
21218  void *argp3 = 0 ;
21219  int res3 = 0 ;
21220  unsigned int val4 ;
21221  int ecode4 = 0 ;
21222  void *argp5 = 0 ;
21223  int res5 = 0 ;
21224  PyObject * obj0 = 0 ;
21225  PyObject * obj1 = 0 ;
21226  PyObject * obj2 = 0 ;
21227  PyObject * obj3 = 0 ;
21228  PyObject * obj4 = 0 ;
21229  libbgp::BgpRib4Entry *result = 0 ;
21230 
21231  if (!PyArg_ParseTuple(args,(char *)"OOOOO:BgpRib4_insert",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21232  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
21233  if (!SWIG_IsOK(res1)) {
21234  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_insert" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
21235  }
21236  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
21237  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
21238  if (!SWIG_IsOK(res2)) {
21239  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib4_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
21240  }
21241  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
21242  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix4, 0 | 0);
21243  if (!SWIG_IsOK(res3)) {
21244  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
21245  }
21246  if (!argp3) {
21247  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
21248  }
21249  arg3 = reinterpret_cast< libbgp::Prefix4 * >(argp3);
21250  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
21251  if (!SWIG_IsOK(ecode4)) {
21252  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BgpRib4_insert" "', argument " "4"" of type '" "uint32_t""'");
21253  }
21254  arg4 = static_cast< uint32_t >(val4);
21255  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_libbgp__RouteEventBus, 0 | 0 );
21256  if (!SWIG_IsOK(res5)) {
21257  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BgpRib4_insert" "', argument " "5"" of type '" "libbgp::RouteEventBus *""'");
21258  }
21259  arg5 = reinterpret_cast< libbgp::RouteEventBus * >(argp5);
21260  result = (libbgp::BgpRib4Entry *)(arg1)->insert(arg2,(libbgp::Prefix4 const &)*arg3,arg4,arg5);
21261  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib4Entry, 0 | 0 );
21262  return resultobj;
21263 fail:
21264  return NULL;
21265 }
21266 
21267 
21268 SWIGINTERN PyObject *_wrap_BgpRib4_insert__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21269  PyObject *resultobj = 0;
21270  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
21272  std::vector< libbgp::Prefix4 > *arg3 = 0 ;
21273  uint32_t arg4 ;
21274  int32_t arg5 ;
21275  void *argp1 = 0 ;
21276  int res1 = 0 ;
21277  void *argp2 = 0 ;
21278  int res2 = 0 ;
21279  void *argp3 = 0 ;
21280  int res3 = 0 ;
21281  unsigned int val4 ;
21282  int ecode4 = 0 ;
21283  int val5 ;
21284  int ecode5 = 0 ;
21285  PyObject * obj0 = 0 ;
21286  PyObject * obj1 = 0 ;
21287  PyObject * obj2 = 0 ;
21288  PyObject * obj3 = 0 ;
21289  PyObject * obj4 = 0 ;
21290  SwigValueWrapper< std::vector< libbgp::BgpRib4Entry > > result;
21291 
21292  if (!PyArg_ParseTuple(args,(char *)"OOOOO:BgpRib4_insert",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21293  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
21294  if (!SWIG_IsOK(res1)) {
21295  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_insert" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
21296  }
21297  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
21298  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
21299  if (!SWIG_IsOK(res2)) {
21300  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib4_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
21301  }
21302  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
21303  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0 | 0);
21304  if (!SWIG_IsOK(res3)) {
21305  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
21306  }
21307  if (!argp3) {
21308  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
21309  }
21310  arg3 = reinterpret_cast< std::vector< libbgp::Prefix4 > * >(argp3);
21311  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
21312  if (!SWIG_IsOK(ecode4)) {
21313  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BgpRib4_insert" "', argument " "4"" of type '" "uint32_t""'");
21314  }
21315  arg4 = static_cast< uint32_t >(val4);
21316  ecode5 = SWIG_AsVal_int(obj4, &val5);
21317  if (!SWIG_IsOK(ecode5)) {
21318  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BgpRib4_insert" "', argument " "5"" of type '" "int32_t""'");
21319  }
21320  arg5 = static_cast< int32_t >(val5);
21321  result = (arg1)->insert(arg2,(std::vector< libbgp::Prefix4 > const &)*arg3,arg4,arg5);
21322  resultobj = SWIG_NewPointerObj((new std::vector< libbgp::BgpRib4Entry >(static_cast< const std::vector< libbgp::BgpRib4Entry >& >(result))), SWIGTYPE_p_std__vectorT_libbgp__BgpRib4Entry_t, SWIG_POINTER_OWN | 0 );
21323  return resultobj;
21324 fail:
21325  return NULL;
21326 }
21327 
21328 
21329 SWIGINTERN PyObject *_wrap_BgpRib4_insert__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21330  PyObject *resultobj = 0;
21331  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
21333  std::vector< libbgp::Prefix4 > *arg3 = 0 ;
21334  uint32_t arg4 ;
21335  void *argp1 = 0 ;
21336  int res1 = 0 ;
21337  void *argp2 = 0 ;
21338  int res2 = 0 ;
21339  void *argp3 = 0 ;
21340  int res3 = 0 ;
21341  unsigned int val4 ;
21342  int ecode4 = 0 ;
21343  PyObject * obj0 = 0 ;
21344  PyObject * obj1 = 0 ;
21345  PyObject * obj2 = 0 ;
21346  PyObject * obj3 = 0 ;
21347  SwigValueWrapper< std::vector< libbgp::BgpRib4Entry > > result;
21348 
21349  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpRib4_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21350  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
21351  if (!SWIG_IsOK(res1)) {
21352  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_insert" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
21353  }
21354  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
21355  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
21356  if (!SWIG_IsOK(res2)) {
21357  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib4_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
21358  }
21359  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
21360  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0 | 0);
21361  if (!SWIG_IsOK(res3)) {
21362  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
21363  }
21364  if (!argp3) {
21365  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
21366  }
21367  arg3 = reinterpret_cast< std::vector< libbgp::Prefix4 > * >(argp3);
21368  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
21369  if (!SWIG_IsOK(ecode4)) {
21370  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BgpRib4_insert" "', argument " "4"" of type '" "uint32_t""'");
21371  }
21372  arg4 = static_cast< uint32_t >(val4);
21373  result = (arg1)->insert(arg2,(std::vector< libbgp::Prefix4 > const &)*arg3,arg4);
21374  resultobj = SWIG_NewPointerObj((new std::vector< libbgp::BgpRib4Entry >(static_cast< const std::vector< libbgp::BgpRib4Entry >& >(result))), SWIGTYPE_p_std__vectorT_libbgp__BgpRib4Entry_t, SWIG_POINTER_OWN | 0 );
21375  return resultobj;
21376 fail:
21377  return NULL;
21378 }
21379 
21380 
21381 SWIGINTERN PyObject *_wrap_BgpRib4_insert__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21382  PyObject *resultobj = 0;
21383  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
21385  std::vector< libbgp::Prefix4 > *arg3 = 0 ;
21386  uint32_t arg4 ;
21388  int32_t arg6 ;
21389  void *argp1 = 0 ;
21390  int res1 = 0 ;
21391  void *argp2 = 0 ;
21392  int res2 = 0 ;
21393  void *argp3 = 0 ;
21394  int res3 = 0 ;
21395  unsigned int val4 ;
21396  int ecode4 = 0 ;
21397  void *argp5 = 0 ;
21398  int res5 = 0 ;
21399  int val6 ;
21400  int ecode6 = 0 ;
21401  PyObject * obj0 = 0 ;
21402  PyObject * obj1 = 0 ;
21403  PyObject * obj2 = 0 ;
21404  PyObject * obj3 = 0 ;
21405  PyObject * obj4 = 0 ;
21406  PyObject * obj5 = 0 ;
21407  SwigValueWrapper< std::vector< libbgp::BgpRib4Entry > > result;
21408 
21409  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BgpRib4_insert",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
21410  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
21411  if (!SWIG_IsOK(res1)) {
21412  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_insert" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
21413  }
21414  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
21415  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
21416  if (!SWIG_IsOK(res2)) {
21417  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib4_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
21418  }
21419  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
21420  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0 | 0);
21421  if (!SWIG_IsOK(res3)) {
21422  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
21423  }
21424  if (!argp3) {
21425  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
21426  }
21427  arg3 = reinterpret_cast< std::vector< libbgp::Prefix4 > * >(argp3);
21428  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
21429  if (!SWIG_IsOK(ecode4)) {
21430  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BgpRib4_insert" "', argument " "4"" of type '" "uint32_t""'");
21431  }
21432  arg4 = static_cast< uint32_t >(val4);
21433  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_libbgp__RouteEventBus, 0 | 0 );
21434  if (!SWIG_IsOK(res5)) {
21435  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BgpRib4_insert" "', argument " "5"" of type '" "libbgp::RouteEventBus *""'");
21436  }
21437  arg5 = reinterpret_cast< libbgp::RouteEventBus * >(argp5);
21438  ecode6 = SWIG_AsVal_int(obj5, &val6);
21439  if (!SWIG_IsOK(ecode6)) {
21440  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BgpRib4_insert" "', argument " "6"" of type '" "int32_t""'");
21441  }
21442  arg6 = static_cast< int32_t >(val6);
21443  result = (arg1)->insert(arg2,(std::vector< libbgp::Prefix4 > const &)*arg3,arg4,arg5,arg6);
21444  resultobj = SWIG_NewPointerObj((new std::vector< libbgp::BgpRib4Entry >(static_cast< const std::vector< libbgp::BgpRib4Entry >& >(result))), SWIGTYPE_p_std__vectorT_libbgp__BgpRib4Entry_t, SWIG_POINTER_OWN | 0 );
21445  return resultobj;
21446 fail:
21447  return NULL;
21448 }
21449 
21450 
21451 SWIGINTERN PyObject *_wrap_BgpRib4_insert__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21452  PyObject *resultobj = 0;
21453  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
21455  std::vector< libbgp::Prefix4 > *arg3 = 0 ;
21456  uint32_t arg4 ;
21458  void *argp1 = 0 ;
21459  int res1 = 0 ;
21460  void *argp2 = 0 ;
21461  int res2 = 0 ;
21462  void *argp3 = 0 ;
21463  int res3 = 0 ;
21464  unsigned int val4 ;
21465  int ecode4 = 0 ;
21466  void *argp5 = 0 ;
21467  int res5 = 0 ;
21468  PyObject * obj0 = 0 ;
21469  PyObject * obj1 = 0 ;
21470  PyObject * obj2 = 0 ;
21471  PyObject * obj3 = 0 ;
21472  PyObject * obj4 = 0 ;
21473  SwigValueWrapper< std::vector< libbgp::BgpRib4Entry > > result;
21474 
21475  if (!PyArg_ParseTuple(args,(char *)"OOOOO:BgpRib4_insert",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21476  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
21477  if (!SWIG_IsOK(res1)) {
21478  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_insert" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
21479  }
21480  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
21481  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
21482  if (!SWIG_IsOK(res2)) {
21483  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib4_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
21484  }
21485  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
21486  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0 | 0);
21487  if (!SWIG_IsOK(res3)) {
21488  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
21489  }
21490  if (!argp3) {
21491  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
21492  }
21493  arg3 = reinterpret_cast< std::vector< libbgp::Prefix4 > * >(argp3);
21494  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
21495  if (!SWIG_IsOK(ecode4)) {
21496  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BgpRib4_insert" "', argument " "4"" of type '" "uint32_t""'");
21497  }
21498  arg4 = static_cast< uint32_t >(val4);
21499  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_libbgp__RouteEventBus, 0 | 0 );
21500  if (!SWIG_IsOK(res5)) {
21501  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BgpRib4_insert" "', argument " "5"" of type '" "libbgp::RouteEventBus *""'");
21502  }
21503  arg5 = reinterpret_cast< libbgp::RouteEventBus * >(argp5);
21504  result = (arg1)->insert(arg2,(std::vector< libbgp::Prefix4 > const &)*arg3,arg4,arg5);
21505  resultobj = SWIG_NewPointerObj((new std::vector< libbgp::BgpRib4Entry >(static_cast< const std::vector< libbgp::BgpRib4Entry >& >(result))), SWIGTYPE_p_std__vectorT_libbgp__BgpRib4Entry_t, SWIG_POINTER_OWN | 0 );
21506  return resultobj;
21507 fail:
21508  return NULL;
21509 }
21510 
21511 
21512 SWIGINTERN PyObject *_wrap_BgpRib4_insert__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21513  PyObject *resultobj = 0;
21514  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
21515  uint32_t arg2 ;
21516  libbgp::Prefix4 *arg3 = 0 ;
21517  std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *arg4 = 0 ;
21518  int32_t arg5 ;
21519  void *argp1 = 0 ;
21520  int res1 = 0 ;
21521  unsigned int val2 ;
21522  int ecode2 = 0 ;
21523  void *argp3 = 0 ;
21524  int res3 = 0 ;
21525  void *argp4 = 0 ;
21526  int res4 = 0 ;
21527  int val5 ;
21528  int ecode5 = 0 ;
21529  PyObject * obj0 = 0 ;
21530  PyObject * obj1 = 0 ;
21531  PyObject * obj2 = 0 ;
21532  PyObject * obj3 = 0 ;
21533  PyObject * obj4 = 0 ;
21534  bool result;
21535 
21536  if (!PyArg_ParseTuple(args,(char *)"OOOOO:BgpRib4_insert",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21537  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
21538  if (!SWIG_IsOK(res1)) {
21539  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_insert" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
21540  }
21541  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
21542  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
21543  if (!SWIG_IsOK(ecode2)) {
21544  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib4_insert" "', argument " "2"" of type '" "uint32_t""'");
21545  }
21546  arg2 = static_cast< uint32_t >(val2);
21547  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix4, 0 | 0);
21548  if (!SWIG_IsOK(res3)) {
21549  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
21550  }
21551  if (!argp3) {
21552  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
21553  }
21554  arg3 = reinterpret_cast< libbgp::Prefix4 * >(argp3);
21555  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0 | 0);
21556  if (!SWIG_IsOK(res4)) {
21557  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpRib4_insert" "', argument " "4"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &""'");
21558  }
21559  if (!argp4) {
21560  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_insert" "', argument " "4"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &""'");
21561  }
21562  arg4 = reinterpret_cast< std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > * >(argp4);
21563  ecode5 = SWIG_AsVal_int(obj4, &val5);
21564  if (!SWIG_IsOK(ecode5)) {
21565  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BgpRib4_insert" "', argument " "5"" of type '" "int32_t""'");
21566  }
21567  arg5 = static_cast< int32_t >(val5);
21568  result = (bool)(arg1)->insert(arg2,(libbgp::Prefix4 const &)*arg3,(std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &)*arg4,arg5);
21569  resultobj = SWIG_From_bool(static_cast< bool >(result));
21570  return resultobj;
21571 fail:
21572  return NULL;
21573 }
21574 
21575 
21576 SWIGINTERN PyObject *_wrap_BgpRib4_insert__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21577  PyObject *resultobj = 0;
21578  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
21579  uint32_t arg2 ;
21580  std::vector< libbgp::Prefix4 > *arg3 = 0 ;
21581  std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *arg4 = 0 ;
21582  int32_t arg5 ;
21583  void *argp1 = 0 ;
21584  int res1 = 0 ;
21585  unsigned int val2 ;
21586  int ecode2 = 0 ;
21587  void *argp3 = 0 ;
21588  int res3 = 0 ;
21589  void *argp4 = 0 ;
21590  int res4 = 0 ;
21591  int val5 ;
21592  int ecode5 = 0 ;
21593  PyObject * obj0 = 0 ;
21594  PyObject * obj1 = 0 ;
21595  PyObject * obj2 = 0 ;
21596  PyObject * obj3 = 0 ;
21597  PyObject * obj4 = 0 ;
21598  ssize_t result;
21599 
21600  if (!PyArg_ParseTuple(args,(char *)"OOOOO:BgpRib4_insert",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21601  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
21602  if (!SWIG_IsOK(res1)) {
21603  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_insert" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
21604  }
21605  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
21606  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
21607  if (!SWIG_IsOK(ecode2)) {
21608  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib4_insert" "', argument " "2"" of type '" "uint32_t""'");
21609  }
21610  arg2 = static_cast< uint32_t >(val2);
21611  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0 | 0);
21612  if (!SWIG_IsOK(res3)) {
21613  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
21614  }
21615  if (!argp3) {
21616  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
21617  }
21618  arg3 = reinterpret_cast< std::vector< libbgp::Prefix4 > * >(argp3);
21619  res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0 | 0);
21620  if (!SWIG_IsOK(res4)) {
21621  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpRib4_insert" "', argument " "4"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &""'");
21622  }
21623  if (!argp4) {
21624  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_insert" "', argument " "4"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &""'");
21625  }
21626  arg4 = reinterpret_cast< std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > * >(argp4);
21627  ecode5 = SWIG_AsVal_int(obj4, &val5);
21628  if (!SWIG_IsOK(ecode5)) {
21629  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BgpRib4_insert" "', argument " "5"" of type '" "int32_t""'");
21630  }
21631  arg5 = static_cast< int32_t >(val5);
21632  result = (arg1)->insert(arg2,(std::vector< libbgp::Prefix4 > const &)*arg3,(std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &)*arg4,arg5);
21633  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
21634  return resultobj;
21635 fail:
21636  return NULL;
21637 }
21638 
21639 
21640 SWIGINTERN PyObject *_wrap_BgpRib4_insert(PyObject *self, PyObject *args) {
21641  Py_ssize_t argc;
21642  PyObject *argv[7] = {
21643  0
21644  };
21645  Py_ssize_t ii;
21646 
21647  if (!PyTuple_Check(args)) SWIG_fail;
21648  argc = args ? PyObject_Length(args) : 0;
21649  for (ii = 0; (ii < 6) && (ii < argc); ii++) {
21650  argv[ii] = PyTuple_GET_ITEM(args,ii);
21651  }
21652  if (argc == 4) {
21653  int _v;
21654  void *vptr = 0;
21655  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
21656  _v = SWIG_CheckState(res);
21657  if (_v) {
21658  void *vptr = 0;
21659  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
21660  _v = SWIG_CheckState(res);
21661  if (_v) {
21662  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_libbgp__Prefix4, 0);
21663  _v = SWIG_CheckState(res);
21664  if (_v) {
21665  {
21666  int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
21667  _v = SWIG_CheckState(res);
21668  }
21669  if (_v) {
21670  return _wrap_BgpRib4_insert__SWIG_1(self, args);
21671  }
21672  }
21673  }
21674  }
21675  }
21676  if (argc == 4) {
21677  int _v;
21678  void *vptr = 0;
21679  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
21680  _v = SWIG_CheckState(res);
21681  if (_v) {
21682  void *vptr = 0;
21683  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
21684  _v = SWIG_CheckState(res);
21685  if (_v) {
21686  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0);
21687  _v = SWIG_CheckState(res);
21688  if (_v) {
21689  {
21690  int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
21691  _v = SWIG_CheckState(res);
21692  }
21693  if (_v) {
21694  return _wrap_BgpRib4_insert__SWIG_5(self, args);
21695  }
21696  }
21697  }
21698  }
21699  }
21700  if (argc == 5) {
21701  int _v;
21702  void *vptr = 0;
21703  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
21704  _v = SWIG_CheckState(res);
21705  if (_v) {
21706  void *vptr = 0;
21707  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
21708  _v = SWIG_CheckState(res);
21709  if (_v) {
21710  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_libbgp__Prefix4, 0);
21711  _v = SWIG_CheckState(res);
21712  if (_v) {
21713  {
21714  int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
21715  _v = SWIG_CheckState(res);
21716  }
21717  if (_v) {
21718  void *vptr = 0;
21719  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_libbgp__RouteEventBus, 0);
21720  _v = SWIG_CheckState(res);
21721  if (_v) {
21722  return _wrap_BgpRib4_insert__SWIG_3(self, args);
21723  }
21724  }
21725  }
21726  }
21727  }
21728  }
21729  if (argc == 5) {
21730  int _v;
21731  void *vptr = 0;
21732  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
21733  _v = SWIG_CheckState(res);
21734  if (_v) {
21735  void *vptr = 0;
21736  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
21737  _v = SWIG_CheckState(res);
21738  if (_v) {
21739  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0);
21740  _v = SWIG_CheckState(res);
21741  if (_v) {
21742  {
21743  int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
21744  _v = SWIG_CheckState(res);
21745  }
21746  if (_v) {
21747  void *vptr = 0;
21748  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_libbgp__RouteEventBus, 0);
21749  _v = SWIG_CheckState(res);
21750  if (_v) {
21751  return _wrap_BgpRib4_insert__SWIG_7(self, args);
21752  }
21753  }
21754  }
21755  }
21756  }
21757  }
21758  if (argc == 5) {
21759  int _v;
21760  void *vptr = 0;
21761  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
21762  _v = SWIG_CheckState(res);
21763  if (_v) {
21764  void *vptr = 0;
21765  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
21766  _v = SWIG_CheckState(res);
21767  if (_v) {
21768  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_libbgp__Prefix4, 0);
21769  _v = SWIG_CheckState(res);
21770  if (_v) {
21771  {
21772  int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
21773  _v = SWIG_CheckState(res);
21774  }
21775  if (_v) {
21776  {
21777  int res = SWIG_AsVal_int(argv[4], NULL);
21778  _v = SWIG_CheckState(res);
21779  }
21780  if (_v) {
21781  return _wrap_BgpRib4_insert__SWIG_0(self, args);
21782  }
21783  }
21784  }
21785  }
21786  }
21787  }
21788  if (argc == 5) {
21789  int _v;
21790  void *vptr = 0;
21791  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
21792  _v = SWIG_CheckState(res);
21793  if (_v) {
21794  void *vptr = 0;
21795  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
21796  _v = SWIG_CheckState(res);
21797  if (_v) {
21798  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0);
21799  _v = SWIG_CheckState(res);
21800  if (_v) {
21801  {
21802  int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
21803  _v = SWIG_CheckState(res);
21804  }
21805  if (_v) {
21806  {
21807  int res = SWIG_AsVal_int(argv[4], NULL);
21808  _v = SWIG_CheckState(res);
21809  }
21810  if (_v) {
21811  return _wrap_BgpRib4_insert__SWIG_4(self, args);
21812  }
21813  }
21814  }
21815  }
21816  }
21817  }
21818  if (argc == 5) {
21819  int _v;
21820  void *vptr = 0;
21821  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
21822  _v = SWIG_CheckState(res);
21823  if (_v) {
21824  {
21825  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
21826  _v = SWIG_CheckState(res);
21827  }
21828  if (_v) {
21829  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_libbgp__Prefix4, 0);
21830  _v = SWIG_CheckState(res);
21831  if (_v) {
21832  int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0);
21833  _v = SWIG_CheckState(res);
21834  if (_v) {
21835  {
21836  int res = SWIG_AsVal_int(argv[4], NULL);
21837  _v = SWIG_CheckState(res);
21838  }
21839  if (_v) {
21840  return _wrap_BgpRib4_insert__SWIG_8(self, args);
21841  }
21842  }
21843  }
21844  }
21845  }
21846  }
21847  if (argc == 5) {
21848  int _v;
21849  void *vptr = 0;
21850  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
21851  _v = SWIG_CheckState(res);
21852  if (_v) {
21853  {
21854  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
21855  _v = SWIG_CheckState(res);
21856  }
21857  if (_v) {
21858  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0);
21859  _v = SWIG_CheckState(res);
21860  if (_v) {
21861  int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0);
21862  _v = SWIG_CheckState(res);
21863  if (_v) {
21864  {
21865  int res = SWIG_AsVal_int(argv[4], NULL);
21866  _v = SWIG_CheckState(res);
21867  }
21868  if (_v) {
21869  return _wrap_BgpRib4_insert__SWIG_9(self, args);
21870  }
21871  }
21872  }
21873  }
21874  }
21875  }
21876  if (argc == 6) {
21877  int _v;
21878  void *vptr = 0;
21879  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
21880  _v = SWIG_CheckState(res);
21881  if (_v) {
21882  void *vptr = 0;
21883  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
21884  _v = SWIG_CheckState(res);
21885  if (_v) {
21886  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0);
21887  _v = SWIG_CheckState(res);
21888  if (_v) {
21889  {
21890  int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
21891  _v = SWIG_CheckState(res);
21892  }
21893  if (_v) {
21894  void *vptr = 0;
21895  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_libbgp__RouteEventBus, 0);
21896  _v = SWIG_CheckState(res);
21897  if (_v) {
21898  {
21899  int res = SWIG_AsVal_int(argv[5], NULL);
21900  _v = SWIG_CheckState(res);
21901  }
21902  if (_v) {
21903  return _wrap_BgpRib4_insert__SWIG_6(self, args);
21904  }
21905  }
21906  }
21907  }
21908  }
21909  }
21910  }
21911  if (argc == 6) {
21912  int _v;
21913  void *vptr = 0;
21914  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
21915  _v = SWIG_CheckState(res);
21916  if (_v) {
21917  void *vptr = 0;
21918  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
21919  _v = SWIG_CheckState(res);
21920  if (_v) {
21921  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_libbgp__Prefix4, 0);
21922  _v = SWIG_CheckState(res);
21923  if (_v) {
21924  {
21925  int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
21926  _v = SWIG_CheckState(res);
21927  }
21928  if (_v) {
21929  void *vptr = 0;
21930  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_libbgp__RouteEventBus, 0);
21931  _v = SWIG_CheckState(res);
21932  if (_v) {
21933  {
21934  int res = SWIG_AsVal_int(argv[5], NULL);
21935  _v = SWIG_CheckState(res);
21936  }
21937  if (_v) {
21938  return _wrap_BgpRib4_insert__SWIG_2(self, args);
21939  }
21940  }
21941  }
21942  }
21943  }
21944  }
21945  }
21946 
21947 fail:
21948  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BgpRib4_insert'.\n"
21949  " Possible C/C++ prototypes are:\n"
21950  " libbgp::BgpRib4::insert(libbgp::BgpLogHandler *,libbgp::Prefix4 const &,uint32_t,int32_t)\n"
21951  " libbgp::BgpRib4::insert(libbgp::BgpLogHandler *,libbgp::Prefix4 const &,uint32_t)\n"
21952  " libbgp::BgpRib4::insert(libbgp::BgpLogHandler *,libbgp::Prefix4 const &,uint32_t,libbgp::RouteEventBus *,int32_t)\n"
21953  " libbgp::BgpRib4::insert(libbgp::BgpLogHandler *,libbgp::Prefix4 const &,uint32_t,libbgp::RouteEventBus *)\n"
21954  " libbgp::BgpRib4::insert(libbgp::BgpLogHandler *,std::vector< libbgp::Prefix4 > const &,uint32_t,int32_t)\n"
21955  " libbgp::BgpRib4::insert(libbgp::BgpLogHandler *,std::vector< libbgp::Prefix4 > const &,uint32_t)\n"
21956  " libbgp::BgpRib4::insert(libbgp::BgpLogHandler *,std::vector< libbgp::Prefix4 > const &,uint32_t,libbgp::RouteEventBus *,int32_t)\n"
21957  " libbgp::BgpRib4::insert(libbgp::BgpLogHandler *,std::vector< libbgp::Prefix4 > const &,uint32_t,libbgp::RouteEventBus *)\n"
21958  " libbgp::BgpRib4::insert(uint32_t,libbgp::Prefix4 const &,std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &,int32_t)\n"
21959  " libbgp::BgpRib4::insert(uint32_t,std::vector< libbgp::Prefix4 > const &,std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &,int32_t)\n");
21960  return 0;
21961 }
21962 
21963 
21964 SWIGINTERN PyObject *_wrap_BgpRib4_withdraw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21965  PyObject *resultobj = 0;
21966  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
21967  uint32_t arg2 ;
21968  libbgp::Prefix4 *arg3 = 0 ;
21969  void *argp1 = 0 ;
21970  int res1 = 0 ;
21971  unsigned int val2 ;
21972  int ecode2 = 0 ;
21973  void *argp3 = 0 ;
21974  int res3 = 0 ;
21975  PyObject * obj0 = 0 ;
21976  PyObject * obj1 = 0 ;
21977  PyObject * obj2 = 0 ;
21978  bool result;
21979 
21980  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpRib4_withdraw",&obj0,&obj1,&obj2)) SWIG_fail;
21981  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
21982  if (!SWIG_IsOK(res1)) {
21983  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_withdraw" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
21984  }
21985  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
21986  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
21987  if (!SWIG_IsOK(ecode2)) {
21988  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib4_withdraw" "', argument " "2"" of type '" "uint32_t""'");
21989  }
21990  arg2 = static_cast< uint32_t >(val2);
21991  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix4, 0 | 0);
21992  if (!SWIG_IsOK(res3)) {
21993  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib4_withdraw" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
21994  }
21995  if (!argp3) {
21996  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_withdraw" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
21997  }
21998  arg3 = reinterpret_cast< libbgp::Prefix4 * >(argp3);
21999  result = (bool)(arg1)->withdraw(arg2,(libbgp::Prefix4 const &)*arg3);
22000  resultobj = SWIG_From_bool(static_cast< bool >(result));
22001  return resultobj;
22002 fail:
22003  return NULL;
22004 }
22005 
22006 
22007 SWIGINTERN PyObject *_wrap_BgpRib4_withdraw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22008  PyObject *resultobj = 0;
22009  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
22010  uint32_t arg2 ;
22011  libbgp::Prefix4 *arg3 = 0 ;
22013  void *argp1 = 0 ;
22014  int res1 = 0 ;
22015  unsigned int val2 ;
22016  int ecode2 = 0 ;
22017  void *argp3 = 0 ;
22018  int res3 = 0 ;
22019  void *argp4 = 0 ;
22020  int res4 = 0 ;
22021  PyObject * obj0 = 0 ;
22022  PyObject * obj1 = 0 ;
22023  PyObject * obj2 = 0 ;
22024  PyObject * obj3 = 0 ;
22025  bool result;
22026 
22027  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpRib4_withdraw",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22028  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
22029  if (!SWIG_IsOK(res1)) {
22030  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_withdraw" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
22031  }
22032  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
22033  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22034  if (!SWIG_IsOK(ecode2)) {
22035  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib4_withdraw" "', argument " "2"" of type '" "uint32_t""'");
22036  }
22037  arg2 = static_cast< uint32_t >(val2);
22038  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix4, 0 | 0);
22039  if (!SWIG_IsOK(res3)) {
22040  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib4_withdraw" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
22041  }
22042  if (!argp3) {
22043  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_withdraw" "', argument " "3"" of type '" "libbgp::Prefix4 const &""'");
22044  }
22045  arg3 = reinterpret_cast< libbgp::Prefix4 * >(argp3);
22046  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_libbgp__RouteEventBus, 0 | 0 );
22047  if (!SWIG_IsOK(res4)) {
22048  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpRib4_withdraw" "', argument " "4"" of type '" "libbgp::RouteEventBus *""'");
22049  }
22050  arg4 = reinterpret_cast< libbgp::RouteEventBus * >(argp4);
22051  result = (bool)(arg1)->withdraw(arg2,(libbgp::Prefix4 const &)*arg3,arg4);
22052  resultobj = SWIG_From_bool(static_cast< bool >(result));
22053  return resultobj;
22054 fail:
22055  return NULL;
22056 }
22057 
22058 
22059 SWIGINTERN PyObject *_wrap_BgpRib4_withdraw__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22060  PyObject *resultobj = 0;
22061  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
22062  uint32_t arg2 ;
22063  std::vector< libbgp::Prefix4 > *arg3 = 0 ;
22064  void *argp1 = 0 ;
22065  int res1 = 0 ;
22066  unsigned int val2 ;
22067  int ecode2 = 0 ;
22068  void *argp3 = 0 ;
22069  int res3 = 0 ;
22070  PyObject * obj0 = 0 ;
22071  PyObject * obj1 = 0 ;
22072  PyObject * obj2 = 0 ;
22073  ssize_t result;
22074 
22075  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpRib4_withdraw",&obj0,&obj1,&obj2)) SWIG_fail;
22076  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
22077  if (!SWIG_IsOK(res1)) {
22078  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_withdraw" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
22079  }
22080  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
22081  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22082  if (!SWIG_IsOK(ecode2)) {
22083  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib4_withdraw" "', argument " "2"" of type '" "uint32_t""'");
22084  }
22085  arg2 = static_cast< uint32_t >(val2);
22086  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0 | 0);
22087  if (!SWIG_IsOK(res3)) {
22088  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib4_withdraw" "', argument " "3"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
22089  }
22090  if (!argp3) {
22091  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_withdraw" "', argument " "3"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
22092  }
22093  arg3 = reinterpret_cast< std::vector< libbgp::Prefix4 > * >(argp3);
22094  result = (arg1)->withdraw(arg2,(std::vector< libbgp::Prefix4 > const &)*arg3);
22095  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
22096  return resultobj;
22097 fail:
22098  return NULL;
22099 }
22100 
22101 
22102 SWIGINTERN PyObject *_wrap_BgpRib4_withdraw__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22103  PyObject *resultobj = 0;
22104  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
22105  uint32_t arg2 ;
22106  std::vector< libbgp::Prefix4 > *arg3 = 0 ;
22108  void *argp1 = 0 ;
22109  int res1 = 0 ;
22110  unsigned int val2 ;
22111  int ecode2 = 0 ;
22112  void *argp3 = 0 ;
22113  int res3 = 0 ;
22114  void *argp4 = 0 ;
22115  int res4 = 0 ;
22116  PyObject * obj0 = 0 ;
22117  PyObject * obj1 = 0 ;
22118  PyObject * obj2 = 0 ;
22119  PyObject * obj3 = 0 ;
22120  ssize_t result;
22121 
22122  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpRib4_withdraw",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22123  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
22124  if (!SWIG_IsOK(res1)) {
22125  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_withdraw" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
22126  }
22127  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
22128  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22129  if (!SWIG_IsOK(ecode2)) {
22130  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib4_withdraw" "', argument " "2"" of type '" "uint32_t""'");
22131  }
22132  arg2 = static_cast< uint32_t >(val2);
22133  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0 | 0);
22134  if (!SWIG_IsOK(res3)) {
22135  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib4_withdraw" "', argument " "3"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
22136  }
22137  if (!argp3) {
22138  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib4_withdraw" "', argument " "3"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
22139  }
22140  arg3 = reinterpret_cast< std::vector< libbgp::Prefix4 > * >(argp3);
22141  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_libbgp__RouteEventBus, 0 | 0 );
22142  if (!SWIG_IsOK(res4)) {
22143  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpRib4_withdraw" "', argument " "4"" of type '" "libbgp::RouteEventBus *""'");
22144  }
22145  arg4 = reinterpret_cast< libbgp::RouteEventBus * >(argp4);
22146  result = (arg1)->withdraw(arg2,(std::vector< libbgp::Prefix4 > const &)*arg3,arg4);
22147  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
22148  return resultobj;
22149 fail:
22150  return NULL;
22151 }
22152 
22153 
22154 SWIGINTERN PyObject *_wrap_BgpRib4_withdraw(PyObject *self, PyObject *args) {
22155  Py_ssize_t argc;
22156  PyObject *argv[5] = {
22157  0
22158  };
22159  Py_ssize_t ii;
22160 
22161  if (!PyTuple_Check(args)) SWIG_fail;
22162  argc = args ? PyObject_Length(args) : 0;
22163  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
22164  argv[ii] = PyTuple_GET_ITEM(args,ii);
22165  }
22166  if (argc == 3) {
22167  int _v;
22168  void *vptr = 0;
22169  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
22170  _v = SWIG_CheckState(res);
22171  if (_v) {
22172  {
22173  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
22174  _v = SWIG_CheckState(res);
22175  }
22176  if (_v) {
22177  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_libbgp__Prefix4, 0);
22178  _v = SWIG_CheckState(res);
22179  if (_v) {
22180  return _wrap_BgpRib4_withdraw__SWIG_0(self, args);
22181  }
22182  }
22183  }
22184  }
22185  if (argc == 3) {
22186  int _v;
22187  void *vptr = 0;
22188  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
22189  _v = SWIG_CheckState(res);
22190  if (_v) {
22191  {
22192  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
22193  _v = SWIG_CheckState(res);
22194  }
22195  if (_v) {
22196  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0);
22197  _v = SWIG_CheckState(res);
22198  if (_v) {
22199  return _wrap_BgpRib4_withdraw__SWIG_2(self, args);
22200  }
22201  }
22202  }
22203  }
22204  if (argc == 4) {
22205  int _v;
22206  void *vptr = 0;
22207  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
22208  _v = SWIG_CheckState(res);
22209  if (_v) {
22210  {
22211  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
22212  _v = SWIG_CheckState(res);
22213  }
22214  if (_v) {
22215  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_libbgp__Prefix4, 0);
22216  _v = SWIG_CheckState(res);
22217  if (_v) {
22218  void *vptr = 0;
22219  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_libbgp__RouteEventBus, 0);
22220  _v = SWIG_CheckState(res);
22221  if (_v) {
22222  return _wrap_BgpRib4_withdraw__SWIG_1(self, args);
22223  }
22224  }
22225  }
22226  }
22227  }
22228  if (argc == 4) {
22229  int _v;
22230  void *vptr = 0;
22231  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
22232  _v = SWIG_CheckState(res);
22233  if (_v) {
22234  {
22235  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
22236  _v = SWIG_CheckState(res);
22237  }
22238  if (_v) {
22239  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0);
22240  _v = SWIG_CheckState(res);
22241  if (_v) {
22242  void *vptr = 0;
22243  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_libbgp__RouteEventBus, 0);
22244  _v = SWIG_CheckState(res);
22245  if (_v) {
22246  return _wrap_BgpRib4_withdraw__SWIG_3(self, args);
22247  }
22248  }
22249  }
22250  }
22251  }
22252 
22253 fail:
22254  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BgpRib4_withdraw'.\n"
22255  " Possible C/C++ prototypes are:\n"
22256  " libbgp::BgpRib4::withdraw(uint32_t,libbgp::Prefix4 const &)\n"
22257  " libbgp::BgpRib4::withdraw(uint32_t,libbgp::Prefix4 const &,libbgp::RouteEventBus *)\n"
22258  " libbgp::BgpRib4::withdraw(uint32_t,std::vector< libbgp::Prefix4 > const &)\n"
22259  " libbgp::BgpRib4::withdraw(uint32_t,std::vector< libbgp::Prefix4 > const &,libbgp::RouteEventBus *)\n");
22260  return 0;
22261 }
22262 
22263 
22264 SWIGINTERN PyObject *_wrap_BgpRib4_discard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22265  PyObject *resultobj = 0;
22266  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
22267  uint32_t arg2 ;
22268  void *argp1 = 0 ;
22269  int res1 = 0 ;
22270  unsigned int val2 ;
22271  int ecode2 = 0 ;
22272  PyObject * obj0 = 0 ;
22273  PyObject * obj1 = 0 ;
22274  SwigValueWrapper< std::vector< libbgp::Prefix4 > > result;
22275 
22276  if (!PyArg_ParseTuple(args,(char *)"OO:BgpRib4_discard",&obj0,&obj1)) SWIG_fail;
22277  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
22278  if (!SWIG_IsOK(res1)) {
22279  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_discard" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
22280  }
22281  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
22282  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22283  if (!SWIG_IsOK(ecode2)) {
22284  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib4_discard" "', argument " "2"" of type '" "uint32_t""'");
22285  }
22286  arg2 = static_cast< uint32_t >(val2);
22287  result = (arg1)->discard(arg2);
22288  resultobj = SWIG_NewPointerObj((new std::vector< libbgp::Prefix4 >(static_cast< const std::vector< libbgp::Prefix4 >& >(result))), SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, SWIG_POINTER_OWN | 0 );
22289  return resultobj;
22290 fail:
22291  return NULL;
22292 }
22293 
22294 
22295 SWIGINTERN PyObject *_wrap_BgpRib4_lookup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22296  PyObject *resultobj = 0;
22297  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
22298  uint32_t arg2 ;
22299  void *argp1 = 0 ;
22300  int res1 = 0 ;
22301  unsigned int val2 ;
22302  int ecode2 = 0 ;
22303  PyObject * obj0 = 0 ;
22304  PyObject * obj1 = 0 ;
22305  libbgp::BgpRib4Entry *result = 0 ;
22306 
22307  if (!PyArg_ParseTuple(args,(char *)"OO:BgpRib4_lookup",&obj0,&obj1)) SWIG_fail;
22308  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
22309  if (!SWIG_IsOK(res1)) {
22310  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_lookup" "', argument " "1"" of type '" "libbgp::BgpRib4 const *""'");
22311  }
22312  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
22313  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22314  if (!SWIG_IsOK(ecode2)) {
22315  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib4_lookup" "', argument " "2"" of type '" "uint32_t""'");
22316  }
22317  arg2 = static_cast< uint32_t >(val2);
22318  result = (libbgp::BgpRib4Entry *)((libbgp::BgpRib4 const *)arg1)->lookup(arg2);
22319  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib4Entry, 0 | 0 );
22320  return resultobj;
22321 fail:
22322  return NULL;
22323 }
22324 
22325 
22326 SWIGINTERN PyObject *_wrap_BgpRib4_lookup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22327  PyObject *resultobj = 0;
22328  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
22329  uint32_t arg2 ;
22330  uint32_t arg3 ;
22331  void *argp1 = 0 ;
22332  int res1 = 0 ;
22333  unsigned int val2 ;
22334  int ecode2 = 0 ;
22335  unsigned int val3 ;
22336  int ecode3 = 0 ;
22337  PyObject * obj0 = 0 ;
22338  PyObject * obj1 = 0 ;
22339  PyObject * obj2 = 0 ;
22340  libbgp::BgpRib4Entry *result = 0 ;
22341 
22342  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpRib4_lookup",&obj0,&obj1,&obj2)) SWIG_fail;
22343  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
22344  if (!SWIG_IsOK(res1)) {
22345  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_lookup" "', argument " "1"" of type '" "libbgp::BgpRib4 const *""'");
22346  }
22347  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
22348  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22349  if (!SWIG_IsOK(ecode2)) {
22350  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib4_lookup" "', argument " "2"" of type '" "uint32_t""'");
22351  }
22352  arg2 = static_cast< uint32_t >(val2);
22353  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
22354  if (!SWIG_IsOK(ecode3)) {
22355  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpRib4_lookup" "', argument " "3"" of type '" "uint32_t""'");
22356  }
22357  arg3 = static_cast< uint32_t >(val3);
22358  result = (libbgp::BgpRib4Entry *)((libbgp::BgpRib4 const *)arg1)->lookup(arg2,arg3);
22359  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib4Entry, 0 | 0 );
22360  return resultobj;
22361 fail:
22362  return NULL;
22363 }
22364 
22365 
22366 SWIGINTERN PyObject *_wrap_BgpRib4_lookup(PyObject *self, PyObject *args) {
22367  Py_ssize_t argc;
22368  PyObject *argv[4] = {
22369  0
22370  };
22371  Py_ssize_t ii;
22372 
22373  if (!PyTuple_Check(args)) SWIG_fail;
22374  argc = args ? PyObject_Length(args) : 0;
22375  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
22376  argv[ii] = PyTuple_GET_ITEM(args,ii);
22377  }
22378  if (argc == 2) {
22379  int _v;
22380  void *vptr = 0;
22381  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
22382  _v = SWIG_CheckState(res);
22383  if (_v) {
22384  {
22385  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
22386  _v = SWIG_CheckState(res);
22387  }
22388  if (_v) {
22389  return _wrap_BgpRib4_lookup__SWIG_0(self, args);
22390  }
22391  }
22392  }
22393  if (argc == 3) {
22394  int _v;
22395  void *vptr = 0;
22396  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib4, 0);
22397  _v = SWIG_CheckState(res);
22398  if (_v) {
22399  {
22400  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
22401  _v = SWIG_CheckState(res);
22402  }
22403  if (_v) {
22404  {
22405  int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
22406  _v = SWIG_CheckState(res);
22407  }
22408  if (_v) {
22409  return _wrap_BgpRib4_lookup__SWIG_1(self, args);
22410  }
22411  }
22412  }
22413  }
22414 
22415 fail:
22416  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BgpRib4_lookup'.\n"
22417  " Possible C/C++ prototypes are:\n"
22418  " libbgp::BgpRib4::lookup(uint32_t) const\n"
22419  " libbgp::BgpRib4::lookup(uint32_t,uint32_t) const\n");
22420  return 0;
22421 }
22422 
22423 
22424 SWIGINTERN PyObject *_wrap_BgpRib4_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22425  PyObject *resultobj = 0;
22426  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
22427  void *argp1 = 0 ;
22428  int res1 = 0 ;
22429  PyObject * obj0 = 0 ;
22430  std::vector< libbgp::BgpRib4Entry > *result = 0 ;
22431 
22432  if (!PyArg_ParseTuple(args,(char *)"O:BgpRib4_get",&obj0)) SWIG_fail;
22433  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, 0 | 0 );
22434  if (!SWIG_IsOK(res1)) {
22435  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib4_get" "', argument " "1"" of type '" "libbgp::BgpRib4 const *""'");
22436  }
22437  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
22438  result = (std::vector< libbgp::BgpRib4Entry > *) &((libbgp::BgpRib4 const *)arg1)->get();
22439  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_libbgp__BgpRib4Entry_t, 0 | 0 );
22440  return resultobj;
22441 fail:
22442  return NULL;
22443 }
22444 
22445 
22446 SWIGINTERN PyObject *_wrap_delete_BgpRib4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22447  PyObject *resultobj = 0;
22448  libbgp::BgpRib4 *arg1 = (libbgp::BgpRib4 *) 0 ;
22449  void *argp1 = 0 ;
22450  int res1 = 0 ;
22451  PyObject * obj0 = 0 ;
22452 
22453  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpRib4",&obj0)) SWIG_fail;
22454  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib4, SWIG_POINTER_DISOWN | 0 );
22455  if (!SWIG_IsOK(res1)) {
22456  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpRib4" "', argument " "1"" of type '" "libbgp::BgpRib4 *""'");
22457  }
22458  arg1 = reinterpret_cast< libbgp::BgpRib4 * >(argp1);
22459  delete arg1;
22460  resultobj = SWIG_Py_Void();
22461  return resultobj;
22462 fail:
22463  return NULL;
22464 }
22465 
22466 
22467 SWIGINTERN PyObject *BgpRib4_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22468  PyObject *obj;
22469  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
22470  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpRib4, SWIG_NewClientData(obj));
22471  return SWIG_Py_Void();
22472 }
22473 
22474 SWIGINTERN PyObject *_wrap_new_BgpRib6Entry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22475  PyObject *resultobj = 0;
22476  libbgp::Prefix6 arg1 ;
22477  uint32_t arg2 ;
22478  uint8_t *arg3 ;
22479  uint8_t *arg4 ;
22480  SwigValueWrapper< std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > > arg5 ;
22481  void *argp1 ;
22482  int res1 = 0 ;
22483  unsigned int val2 ;
22484  int ecode2 = 0 ;
22485  void *argp3 = 0 ;
22486  int res3 = 0 ;
22487  void *argp4 = 0 ;
22488  int res4 = 0 ;
22489  void *argp5 ;
22490  int res5 = 0 ;
22491  PyObject * obj0 = 0 ;
22492  PyObject * obj1 = 0 ;
22493  PyObject * obj2 = 0 ;
22494  PyObject * obj3 = 0 ;
22495  PyObject * obj4 = 0 ;
22496  libbgp::BgpRib6Entry *result = 0 ;
22497 
22498  if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_BgpRib6Entry",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22499  {
22500  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_libbgp__Prefix6, 0 | 0);
22501  if (!SWIG_IsOK(res1)) {
22502  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpRib6Entry" "', argument " "1"" of type '" "libbgp::Prefix6""'");
22503  }
22504  if (!argp1) {
22505  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BgpRib6Entry" "', argument " "1"" of type '" "libbgp::Prefix6""'");
22506  } else {
22507  libbgp::Prefix6 * temp = reinterpret_cast< libbgp::Prefix6 * >(argp1);
22508  arg1 = *temp;
22509  if (SWIG_IsNewObj(res1)) delete temp;
22510  }
22511  }
22512  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22513  if (!SWIG_IsOK(ecode2)) {
22514  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpRib6Entry" "', argument " "2"" of type '" "uint32_t""'");
22515  }
22516  arg2 = static_cast< uint32_t >(val2);
22517  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 );
22518  if (!SWIG_IsOK(res3)) {
22519  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BgpRib6Entry" "', argument " "3"" of type '" "uint8_t const [16]""'");
22520  }
22521  arg3 = reinterpret_cast< uint8_t * >(argp3);
22522  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
22523  if (!SWIG_IsOK(res4)) {
22524  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_BgpRib6Entry" "', argument " "4"" of type '" "uint8_t const [16]""'");
22525  }
22526  arg4 = reinterpret_cast< uint8_t * >(argp4);
22527  {
22528  res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0 | 0);
22529  if (!SWIG_IsOK(res5)) {
22530  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_BgpRib6Entry" "', argument " "5"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const""'");
22531  }
22532  if (!argp5) {
22533  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BgpRib6Entry" "', argument " "5"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const""'");
22534  } else {
22535  std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > * temp = reinterpret_cast< std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > * >(argp5);
22536  arg5 = *temp;
22537  if (SWIG_IsNewObj(res5)) delete temp;
22538  }
22539  }
22540  result = (libbgp::BgpRib6Entry *)new libbgp::BgpRib6Entry(arg1,arg2,(uint8_t const (*))arg3,(uint8_t const (*))arg4,arg5);
22541  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib6Entry, SWIG_POINTER_NEW | 0 );
22542  return resultobj;
22543 fail:
22544  return NULL;
22545 }
22546 
22547 
22548 SWIGINTERN PyObject *_wrap_BgpRib6Entry_route_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22549  PyObject *resultobj = 0;
22551  libbgp::Prefix6 *arg2 = (libbgp::Prefix6 *) 0 ;
22552  void *argp1 = 0 ;
22553  int res1 = 0 ;
22554  void *argp2 = 0 ;
22555  int res2 = 0 ;
22556  PyObject * obj0 = 0 ;
22557  PyObject * obj1 = 0 ;
22558 
22559  if (!PyArg_ParseTuple(args,(char *)"OO:BgpRib6Entry_route_set",&obj0,&obj1)) SWIG_fail;
22560  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6Entry, 0 | 0 );
22561  if (!SWIG_IsOK(res1)) {
22562  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6Entry_route_set" "', argument " "1"" of type '" "libbgp::BgpRib6Entry *""'");
22563  }
22564  arg1 = reinterpret_cast< libbgp::BgpRib6Entry * >(argp1);
22565  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
22566  if (!SWIG_IsOK(res2)) {
22567  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib6Entry_route_set" "', argument " "2"" of type '" "libbgp::Prefix6 *""'");
22568  }
22569  arg2 = reinterpret_cast< libbgp::Prefix6 * >(argp2);
22570  if (arg1) (arg1)->route = *arg2;
22571  resultobj = SWIG_Py_Void();
22572  return resultobj;
22573 fail:
22574  return NULL;
22575 }
22576 
22577 
22578 SWIGINTERN PyObject *_wrap_BgpRib6Entry_route_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22579  PyObject *resultobj = 0;
22581  void *argp1 = 0 ;
22582  int res1 = 0 ;
22583  PyObject * obj0 = 0 ;
22584  libbgp::Prefix6 *result = 0 ;
22585 
22586  if (!PyArg_ParseTuple(args,(char *)"O:BgpRib6Entry_route_get",&obj0)) SWIG_fail;
22587  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6Entry, 0 | 0 );
22588  if (!SWIG_IsOK(res1)) {
22589  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6Entry_route_get" "', argument " "1"" of type '" "libbgp::BgpRib6Entry *""'");
22590  }
22591  arg1 = reinterpret_cast< libbgp::BgpRib6Entry * >(argp1);
22592  result = (libbgp::Prefix6 *)& ((arg1)->route);
22593  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__Prefix6, 0 | 0 );
22594  return resultobj;
22595 fail:
22596  return NULL;
22597 }
22598 
22599 
22600 SWIGINTERN PyObject *_wrap_BgpRib6Entry_nexthop_global_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22601  PyObject *resultobj = 0;
22603  uint8_t *arg2 ;
22604  void *argp1 = 0 ;
22605  int res1 = 0 ;
22606  void *argp2 = 0 ;
22607  int res2 = 0 ;
22608  PyObject * obj0 = 0 ;
22609  PyObject * obj1 = 0 ;
22610 
22611  if (!PyArg_ParseTuple(args,(char *)"OO:BgpRib6Entry_nexthop_global_set",&obj0,&obj1)) SWIG_fail;
22612  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6Entry, 0 | 0 );
22613  if (!SWIG_IsOK(res1)) {
22614  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6Entry_nexthop_global_set" "', argument " "1"" of type '" "libbgp::BgpRib6Entry *""'");
22615  }
22616  arg1 = reinterpret_cast< libbgp::BgpRib6Entry * >(argp1);
22617  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
22618  if (!SWIG_IsOK(res2)) {
22619  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib6Entry_nexthop_global_set" "', argument " "2"" of type '" "uint8_t [16]""'");
22620  }
22621  arg2 = reinterpret_cast< uint8_t * >(argp2);
22622  {
22623  if (arg2) {
22624  size_t ii = 0;
22625  for (; ii < (size_t)16; ++ii) *(uint8_t *)&arg1->nexthop_global[ii] = *((uint8_t *)arg2 + ii);
22626  } else {
22627  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""nexthop_global""' of type '""uint8_t [16]""'");
22628  }
22629  }
22630  resultobj = SWIG_Py_Void();
22631  return resultobj;
22632 fail:
22633  return NULL;
22634 }
22635 
22636 
22637 SWIGINTERN PyObject *_wrap_BgpRib6Entry_nexthop_global_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22638  PyObject *resultobj = 0;
22640  void *argp1 = 0 ;
22641  int res1 = 0 ;
22642  PyObject * obj0 = 0 ;
22643  uint8_t *result = 0 ;
22644 
22645  if (!PyArg_ParseTuple(args,(char *)"O:BgpRib6Entry_nexthop_global_get",&obj0)) SWIG_fail;
22646  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6Entry, 0 | 0 );
22647  if (!SWIG_IsOK(res1)) {
22648  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6Entry_nexthop_global_get" "', argument " "1"" of type '" "libbgp::BgpRib6Entry *""'");
22649  }
22650  arg1 = reinterpret_cast< libbgp::BgpRib6Entry * >(argp1);
22651  result = (uint8_t *)(uint8_t *) ((arg1)->nexthop_global);
22652  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
22653  return resultobj;
22654 fail:
22655  return NULL;
22656 }
22657 
22658 
22659 SWIGINTERN PyObject *_wrap_BgpRib6Entry_nexthop_linklocal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22660  PyObject *resultobj = 0;
22662  uint8_t *arg2 ;
22663  void *argp1 = 0 ;
22664  int res1 = 0 ;
22665  void *argp2 = 0 ;
22666  int res2 = 0 ;
22667  PyObject * obj0 = 0 ;
22668  PyObject * obj1 = 0 ;
22669 
22670  if (!PyArg_ParseTuple(args,(char *)"OO:BgpRib6Entry_nexthop_linklocal_set",&obj0,&obj1)) SWIG_fail;
22671  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6Entry, 0 | 0 );
22672  if (!SWIG_IsOK(res1)) {
22673  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6Entry_nexthop_linklocal_set" "', argument " "1"" of type '" "libbgp::BgpRib6Entry *""'");
22674  }
22675  arg1 = reinterpret_cast< libbgp::BgpRib6Entry * >(argp1);
22676  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
22677  if (!SWIG_IsOK(res2)) {
22678  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib6Entry_nexthop_linklocal_set" "', argument " "2"" of type '" "uint8_t [16]""'");
22679  }
22680  arg2 = reinterpret_cast< uint8_t * >(argp2);
22681  {
22682  if (arg2) {
22683  size_t ii = 0;
22684  for (; ii < (size_t)16; ++ii) *(uint8_t *)&arg1->nexthop_linklocal[ii] = *((uint8_t *)arg2 + ii);
22685  } else {
22686  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""nexthop_linklocal""' of type '""uint8_t [16]""'");
22687  }
22688  }
22689  resultobj = SWIG_Py_Void();
22690  return resultobj;
22691 fail:
22692  return NULL;
22693 }
22694 
22695 
22696 SWIGINTERN PyObject *_wrap_BgpRib6Entry_nexthop_linklocal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22697  PyObject *resultobj = 0;
22699  void *argp1 = 0 ;
22700  int res1 = 0 ;
22701  PyObject * obj0 = 0 ;
22702  uint8_t *result = 0 ;
22703 
22704  if (!PyArg_ParseTuple(args,(char *)"O:BgpRib6Entry_nexthop_linklocal_get",&obj0)) SWIG_fail;
22705  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6Entry, 0 | 0 );
22706  if (!SWIG_IsOK(res1)) {
22707  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6Entry_nexthop_linklocal_get" "', argument " "1"" of type '" "libbgp::BgpRib6Entry *""'");
22708  }
22709  arg1 = reinterpret_cast< libbgp::BgpRib6Entry * >(argp1);
22710  result = (uint8_t *)(uint8_t *) ((arg1)->nexthop_linklocal);
22711  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
22712  return resultobj;
22713 fail:
22714  return NULL;
22715 }
22716 
22717 
22718 SWIGINTERN PyObject *_wrap_delete_BgpRib6Entry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22719  PyObject *resultobj = 0;
22721  void *argp1 = 0 ;
22722  int res1 = 0 ;
22723  PyObject * obj0 = 0 ;
22724 
22725  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpRib6Entry",&obj0)) SWIG_fail;
22726  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6Entry, SWIG_POINTER_DISOWN | 0 );
22727  if (!SWIG_IsOK(res1)) {
22728  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpRib6Entry" "', argument " "1"" of type '" "libbgp::BgpRib6Entry *""'");
22729  }
22730  arg1 = reinterpret_cast< libbgp::BgpRib6Entry * >(argp1);
22731  delete arg1;
22732  resultobj = SWIG_Py_Void();
22733  return resultobj;
22734 fail:
22735  return NULL;
22736 }
22737 
22738 
22739 SWIGINTERN PyObject *BgpRib6Entry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22740  PyObject *obj;
22741  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
22742  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpRib6Entry, SWIG_NewClientData(obj));
22743  return SWIG_Py_Void();
22744 }
22745 
22746 SWIGINTERN PyObject *_wrap_new_BgpRib6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22747  PyObject *resultobj = 0;
22749  void *argp1 = 0 ;
22750  int res1 = 0 ;
22751  PyObject * obj0 = 0 ;
22752  libbgp::BgpRib6 *result = 0 ;
22753 
22754  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpRib6",&obj0)) SWIG_fail;
22755  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
22756  if (!SWIG_IsOK(res1)) {
22757  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpRib6" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
22758  }
22759  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
22760  result = (libbgp::BgpRib6 *)new libbgp::BgpRib6(arg1);
22761  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib6, SWIG_POINTER_NEW | 0 );
22762  return resultobj;
22763 fail:
22764  return NULL;
22765 }
22766 
22767 
22768 SWIGINTERN PyObject *_wrap_BgpRib6_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22769  PyObject *resultobj = 0;
22770  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
22772  libbgp::Prefix6 *arg3 = 0 ;
22773  uint8_t *arg4 ;
22774  uint8_t *arg5 ;
22775  int32_t arg6 ;
22776  void *argp1 = 0 ;
22777  int res1 = 0 ;
22778  void *argp2 = 0 ;
22779  int res2 = 0 ;
22780  void *argp3 = 0 ;
22781  int res3 = 0 ;
22782  void *argp4 = 0 ;
22783  int res4 = 0 ;
22784  void *argp5 = 0 ;
22785  int res5 = 0 ;
22786  int val6 ;
22787  int ecode6 = 0 ;
22788  PyObject * obj0 = 0 ;
22789  PyObject * obj1 = 0 ;
22790  PyObject * obj2 = 0 ;
22791  PyObject * obj3 = 0 ;
22792  PyObject * obj4 = 0 ;
22793  PyObject * obj5 = 0 ;
22794  libbgp::BgpRib6Entry *result = 0 ;
22795 
22796  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BgpRib6_insert",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
22797  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
22798  if (!SWIG_IsOK(res1)) {
22799  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_insert" "', argument " "1"" of type '" "libbgp::BgpRib6 *""'");
22800  }
22801  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
22802  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
22803  if (!SWIG_IsOK(res2)) {
22804  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib6_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
22805  }
22806  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
22807  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix6, 0 | 0);
22808  if (!SWIG_IsOK(res3)) {
22809  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "libbgp::Prefix6 const &""'");
22810  }
22811  if (!argp3) {
22812  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "libbgp::Prefix6 const &""'");
22813  }
22814  arg3 = reinterpret_cast< libbgp::Prefix6 * >(argp3);
22815  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
22816  if (!SWIG_IsOK(res4)) {
22817  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpRib6_insert" "', argument " "4"" of type '" "uint8_t const [16]""'");
22818  }
22819  arg4 = reinterpret_cast< uint8_t * >(argp4);
22820  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_char, 0 | 0 );
22821  if (!SWIG_IsOK(res5)) {
22822  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BgpRib6_insert" "', argument " "5"" of type '" "uint8_t const [16]""'");
22823  }
22824  arg5 = reinterpret_cast< uint8_t * >(argp5);
22825  ecode6 = SWIG_AsVal_int(obj5, &val6);
22826  if (!SWIG_IsOK(ecode6)) {
22827  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BgpRib6_insert" "', argument " "6"" of type '" "int32_t""'");
22828  }
22829  arg6 = static_cast< int32_t >(val6);
22830  result = (libbgp::BgpRib6Entry *)(arg1)->insert(arg2,(libbgp::Prefix6 const &)*arg3,(uint8_t const (*))arg4,(uint8_t const (*))arg5,arg6);
22831  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib6Entry, 0 | 0 );
22832  return resultobj;
22833 fail:
22834  return NULL;
22835 }
22836 
22837 
22838 SWIGINTERN PyObject *_wrap_BgpRib6_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22839  PyObject *resultobj = 0;
22840  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
22842  libbgp::Prefix6 *arg3 = 0 ;
22843  uint8_t *arg4 ;
22844  uint8_t *arg5 ;
22845  void *argp1 = 0 ;
22846  int res1 = 0 ;
22847  void *argp2 = 0 ;
22848  int res2 = 0 ;
22849  void *argp3 = 0 ;
22850  int res3 = 0 ;
22851  void *argp4 = 0 ;
22852  int res4 = 0 ;
22853  void *argp5 = 0 ;
22854  int res5 = 0 ;
22855  PyObject * obj0 = 0 ;
22856  PyObject * obj1 = 0 ;
22857  PyObject * obj2 = 0 ;
22858  PyObject * obj3 = 0 ;
22859  PyObject * obj4 = 0 ;
22860  libbgp::BgpRib6Entry *result = 0 ;
22861 
22862  if (!PyArg_ParseTuple(args,(char *)"OOOOO:BgpRib6_insert",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22863  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
22864  if (!SWIG_IsOK(res1)) {
22865  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_insert" "', argument " "1"" of type '" "libbgp::BgpRib6 *""'");
22866  }
22867  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
22868  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
22869  if (!SWIG_IsOK(res2)) {
22870  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib6_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
22871  }
22872  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
22873  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix6, 0 | 0);
22874  if (!SWIG_IsOK(res3)) {
22875  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "libbgp::Prefix6 const &""'");
22876  }
22877  if (!argp3) {
22878  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "libbgp::Prefix6 const &""'");
22879  }
22880  arg3 = reinterpret_cast< libbgp::Prefix6 * >(argp3);
22881  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
22882  if (!SWIG_IsOK(res4)) {
22883  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpRib6_insert" "', argument " "4"" of type '" "uint8_t const [16]""'");
22884  }
22885  arg4 = reinterpret_cast< uint8_t * >(argp4);
22886  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_char, 0 | 0 );
22887  if (!SWIG_IsOK(res5)) {
22888  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BgpRib6_insert" "', argument " "5"" of type '" "uint8_t const [16]""'");
22889  }
22890  arg5 = reinterpret_cast< uint8_t * >(argp5);
22891  result = (libbgp::BgpRib6Entry *)(arg1)->insert(arg2,(libbgp::Prefix6 const &)*arg3,(uint8_t const (*))arg4,(uint8_t const (*))arg5);
22892  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib6Entry, 0 | 0 );
22893  return resultobj;
22894 fail:
22895  return NULL;
22896 }
22897 
22898 
22899 SWIGINTERN PyObject *_wrap_BgpRib6_insert__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22900  PyObject *resultobj = 0;
22901  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
22903  libbgp::Prefix6 *arg3 = 0 ;
22904  uint8_t *arg4 ;
22905  uint8_t *arg5 ;
22907  int32_t arg7 ;
22908  void *argp1 = 0 ;
22909  int res1 = 0 ;
22910  void *argp2 = 0 ;
22911  int res2 = 0 ;
22912  void *argp3 = 0 ;
22913  int res3 = 0 ;
22914  void *argp4 = 0 ;
22915  int res4 = 0 ;
22916  void *argp5 = 0 ;
22917  int res5 = 0 ;
22918  void *argp6 = 0 ;
22919  int res6 = 0 ;
22920  int val7 ;
22921  int ecode7 = 0 ;
22922  PyObject * obj0 = 0 ;
22923  PyObject * obj1 = 0 ;
22924  PyObject * obj2 = 0 ;
22925  PyObject * obj3 = 0 ;
22926  PyObject * obj4 = 0 ;
22927  PyObject * obj5 = 0 ;
22928  PyObject * obj6 = 0 ;
22929  libbgp::BgpRib6Entry *result = 0 ;
22930 
22931  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BgpRib6_insert",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22932  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
22933  if (!SWIG_IsOK(res1)) {
22934  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_insert" "', argument " "1"" of type '" "libbgp::BgpRib6 *""'");
22935  }
22936  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
22937  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
22938  if (!SWIG_IsOK(res2)) {
22939  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib6_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
22940  }
22941  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
22942  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix6, 0 | 0);
22943  if (!SWIG_IsOK(res3)) {
22944  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "libbgp::Prefix6 const &""'");
22945  }
22946  if (!argp3) {
22947  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "libbgp::Prefix6 const &""'");
22948  }
22949  arg3 = reinterpret_cast< libbgp::Prefix6 * >(argp3);
22950  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
22951  if (!SWIG_IsOK(res4)) {
22952  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpRib6_insert" "', argument " "4"" of type '" "uint8_t const [16]""'");
22953  }
22954  arg4 = reinterpret_cast< uint8_t * >(argp4);
22955  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_char, 0 | 0 );
22956  if (!SWIG_IsOK(res5)) {
22957  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BgpRib6_insert" "', argument " "5"" of type '" "uint8_t const [16]""'");
22958  }
22959  arg5 = reinterpret_cast< uint8_t * >(argp5);
22960  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_libbgp__RouteEventBus, 0 | 0 );
22961  if (!SWIG_IsOK(res6)) {
22962  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BgpRib6_insert" "', argument " "6"" of type '" "libbgp::RouteEventBus *""'");
22963  }
22964  arg6 = reinterpret_cast< libbgp::RouteEventBus * >(argp6);
22965  ecode7 = SWIG_AsVal_int(obj6, &val7);
22966  if (!SWIG_IsOK(ecode7)) {
22967  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BgpRib6_insert" "', argument " "7"" of type '" "int32_t""'");
22968  }
22969  arg7 = static_cast< int32_t >(val7);
22970  result = (libbgp::BgpRib6Entry *)(arg1)->insert(arg2,(libbgp::Prefix6 const &)*arg3,(uint8_t const (*))arg4,(uint8_t const (*))arg5,arg6,arg7);
22971  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib6Entry, 0 | 0 );
22972  return resultobj;
22973 fail:
22974  return NULL;
22975 }
22976 
22977 
22978 SWIGINTERN PyObject *_wrap_BgpRib6_insert__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22979  PyObject *resultobj = 0;
22980  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
22982  libbgp::Prefix6 *arg3 = 0 ;
22983  uint8_t *arg4 ;
22984  uint8_t *arg5 ;
22986  void *argp1 = 0 ;
22987  int res1 = 0 ;
22988  void *argp2 = 0 ;
22989  int res2 = 0 ;
22990  void *argp3 = 0 ;
22991  int res3 = 0 ;
22992  void *argp4 = 0 ;
22993  int res4 = 0 ;
22994  void *argp5 = 0 ;
22995  int res5 = 0 ;
22996  void *argp6 = 0 ;
22997  int res6 = 0 ;
22998  PyObject * obj0 = 0 ;
22999  PyObject * obj1 = 0 ;
23000  PyObject * obj2 = 0 ;
23001  PyObject * obj3 = 0 ;
23002  PyObject * obj4 = 0 ;
23003  PyObject * obj5 = 0 ;
23004  libbgp::BgpRib6Entry *result = 0 ;
23005 
23006  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BgpRib6_insert",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
23007  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
23008  if (!SWIG_IsOK(res1)) {
23009  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_insert" "', argument " "1"" of type '" "libbgp::BgpRib6 *""'");
23010  }
23011  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
23012  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
23013  if (!SWIG_IsOK(res2)) {
23014  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib6_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
23015  }
23016  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
23017  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix6, 0 | 0);
23018  if (!SWIG_IsOK(res3)) {
23019  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "libbgp::Prefix6 const &""'");
23020  }
23021  if (!argp3) {
23022  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "libbgp::Prefix6 const &""'");
23023  }
23024  arg3 = reinterpret_cast< libbgp::Prefix6 * >(argp3);
23025  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
23026  if (!SWIG_IsOK(res4)) {
23027  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpRib6_insert" "', argument " "4"" of type '" "uint8_t const [16]""'");
23028  }
23029  arg4 = reinterpret_cast< uint8_t * >(argp4);
23030  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_char, 0 | 0 );
23031  if (!SWIG_IsOK(res5)) {
23032  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BgpRib6_insert" "', argument " "5"" of type '" "uint8_t const [16]""'");
23033  }
23034  arg5 = reinterpret_cast< uint8_t * >(argp5);
23035  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_libbgp__RouteEventBus, 0 | 0 );
23036  if (!SWIG_IsOK(res6)) {
23037  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BgpRib6_insert" "', argument " "6"" of type '" "libbgp::RouteEventBus *""'");
23038  }
23039  arg6 = reinterpret_cast< libbgp::RouteEventBus * >(argp6);
23040  result = (libbgp::BgpRib6Entry *)(arg1)->insert(arg2,(libbgp::Prefix6 const &)*arg3,(uint8_t const (*))arg4,(uint8_t const (*))arg5,arg6);
23041  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib6Entry, 0 | 0 );
23042  return resultobj;
23043 fail:
23044  return NULL;
23045 }
23046 
23047 
23048 SWIGINTERN PyObject *_wrap_BgpRib6_insert__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23049  PyObject *resultobj = 0;
23050  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
23052  std::vector< libbgp::Prefix6 > *arg3 = 0 ;
23053  uint8_t *arg4 ;
23054  uint8_t *arg5 ;
23055  int32_t arg6 ;
23056  void *argp1 = 0 ;
23057  int res1 = 0 ;
23058  void *argp2 = 0 ;
23059  int res2 = 0 ;
23060  void *argp3 = 0 ;
23061  int res3 = 0 ;
23062  void *argp4 = 0 ;
23063  int res4 = 0 ;
23064  void *argp5 = 0 ;
23065  int res5 = 0 ;
23066  int val6 ;
23067  int ecode6 = 0 ;
23068  PyObject * obj0 = 0 ;
23069  PyObject * obj1 = 0 ;
23070  PyObject * obj2 = 0 ;
23071  PyObject * obj3 = 0 ;
23072  PyObject * obj4 = 0 ;
23073  PyObject * obj5 = 0 ;
23074  SwigValueWrapper< std::vector< libbgp::BgpRib6Entry > > result;
23075 
23076  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BgpRib6_insert",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
23077  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
23078  if (!SWIG_IsOK(res1)) {
23079  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_insert" "', argument " "1"" of type '" "libbgp::BgpRib6 *""'");
23080  }
23081  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
23082  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
23083  if (!SWIG_IsOK(res2)) {
23084  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib6_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
23085  }
23086  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
23087  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0 | 0);
23088  if (!SWIG_IsOK(res3)) {
23089  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
23090  }
23091  if (!argp3) {
23092  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
23093  }
23094  arg3 = reinterpret_cast< std::vector< libbgp::Prefix6 > * >(argp3);
23095  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
23096  if (!SWIG_IsOK(res4)) {
23097  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpRib6_insert" "', argument " "4"" of type '" "uint8_t const [16]""'");
23098  }
23099  arg4 = reinterpret_cast< uint8_t * >(argp4);
23100  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_char, 0 | 0 );
23101  if (!SWIG_IsOK(res5)) {
23102  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BgpRib6_insert" "', argument " "5"" of type '" "uint8_t const [16]""'");
23103  }
23104  arg5 = reinterpret_cast< uint8_t * >(argp5);
23105  ecode6 = SWIG_AsVal_int(obj5, &val6);
23106  if (!SWIG_IsOK(ecode6)) {
23107  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "BgpRib6_insert" "', argument " "6"" of type '" "int32_t""'");
23108  }
23109  arg6 = static_cast< int32_t >(val6);
23110  result = (arg1)->insert(arg2,(std::vector< libbgp::Prefix6 > const &)*arg3,(uint8_t const (*))arg4,(uint8_t const (*))arg5,arg6);
23111  resultobj = SWIG_NewPointerObj((new std::vector< libbgp::BgpRib6Entry >(static_cast< const std::vector< libbgp::BgpRib6Entry >& >(result))), SWIGTYPE_p_std__vectorT_libbgp__BgpRib6Entry_t, SWIG_POINTER_OWN | 0 );
23112  return resultobj;
23113 fail:
23114  return NULL;
23115 }
23116 
23117 
23118 SWIGINTERN PyObject *_wrap_BgpRib6_insert__SWIG_5(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23119  PyObject *resultobj = 0;
23120  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
23122  std::vector< libbgp::Prefix6 > *arg3 = 0 ;
23123  uint8_t *arg4 ;
23124  uint8_t *arg5 ;
23125  void *argp1 = 0 ;
23126  int res1 = 0 ;
23127  void *argp2 = 0 ;
23128  int res2 = 0 ;
23129  void *argp3 = 0 ;
23130  int res3 = 0 ;
23131  void *argp4 = 0 ;
23132  int res4 = 0 ;
23133  void *argp5 = 0 ;
23134  int res5 = 0 ;
23135  PyObject * obj0 = 0 ;
23136  PyObject * obj1 = 0 ;
23137  PyObject * obj2 = 0 ;
23138  PyObject * obj3 = 0 ;
23139  PyObject * obj4 = 0 ;
23140  SwigValueWrapper< std::vector< libbgp::BgpRib6Entry > > result;
23141 
23142  if (!PyArg_ParseTuple(args,(char *)"OOOOO:BgpRib6_insert",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23143  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
23144  if (!SWIG_IsOK(res1)) {
23145  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_insert" "', argument " "1"" of type '" "libbgp::BgpRib6 *""'");
23146  }
23147  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
23148  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
23149  if (!SWIG_IsOK(res2)) {
23150  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib6_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
23151  }
23152  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
23153  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0 | 0);
23154  if (!SWIG_IsOK(res3)) {
23155  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
23156  }
23157  if (!argp3) {
23158  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
23159  }
23160  arg3 = reinterpret_cast< std::vector< libbgp::Prefix6 > * >(argp3);
23161  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
23162  if (!SWIG_IsOK(res4)) {
23163  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpRib6_insert" "', argument " "4"" of type '" "uint8_t const [16]""'");
23164  }
23165  arg4 = reinterpret_cast< uint8_t * >(argp4);
23166  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_char, 0 | 0 );
23167  if (!SWIG_IsOK(res5)) {
23168  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BgpRib6_insert" "', argument " "5"" of type '" "uint8_t const [16]""'");
23169  }
23170  arg5 = reinterpret_cast< uint8_t * >(argp5);
23171  result = (arg1)->insert(arg2,(std::vector< libbgp::Prefix6 > const &)*arg3,(uint8_t const (*))arg4,(uint8_t const (*))arg5);
23172  resultobj = SWIG_NewPointerObj((new std::vector< libbgp::BgpRib6Entry >(static_cast< const std::vector< libbgp::BgpRib6Entry >& >(result))), SWIGTYPE_p_std__vectorT_libbgp__BgpRib6Entry_t, SWIG_POINTER_OWN | 0 );
23173  return resultobj;
23174 fail:
23175  return NULL;
23176 }
23177 
23178 
23179 SWIGINTERN PyObject *_wrap_BgpRib6_insert__SWIG_6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23180  PyObject *resultobj = 0;
23181  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
23183  std::vector< libbgp::Prefix6 > *arg3 = 0 ;
23184  uint8_t *arg4 ;
23185  uint8_t *arg5 ;
23187  int32_t arg7 ;
23188  void *argp1 = 0 ;
23189  int res1 = 0 ;
23190  void *argp2 = 0 ;
23191  int res2 = 0 ;
23192  void *argp3 = 0 ;
23193  int res3 = 0 ;
23194  void *argp4 = 0 ;
23195  int res4 = 0 ;
23196  void *argp5 = 0 ;
23197  int res5 = 0 ;
23198  void *argp6 = 0 ;
23199  int res6 = 0 ;
23200  int val7 ;
23201  int ecode7 = 0 ;
23202  PyObject * obj0 = 0 ;
23203  PyObject * obj1 = 0 ;
23204  PyObject * obj2 = 0 ;
23205  PyObject * obj3 = 0 ;
23206  PyObject * obj4 = 0 ;
23207  PyObject * obj5 = 0 ;
23208  PyObject * obj6 = 0 ;
23209  SwigValueWrapper< std::vector< libbgp::BgpRib6Entry > > result;
23210 
23211  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BgpRib6_insert",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23212  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
23213  if (!SWIG_IsOK(res1)) {
23214  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_insert" "', argument " "1"" of type '" "libbgp::BgpRib6 *""'");
23215  }
23216  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
23217  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
23218  if (!SWIG_IsOK(res2)) {
23219  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib6_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
23220  }
23221  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
23222  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0 | 0);
23223  if (!SWIG_IsOK(res3)) {
23224  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
23225  }
23226  if (!argp3) {
23227  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
23228  }
23229  arg3 = reinterpret_cast< std::vector< libbgp::Prefix6 > * >(argp3);
23230  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
23231  if (!SWIG_IsOK(res4)) {
23232  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpRib6_insert" "', argument " "4"" of type '" "uint8_t const [16]""'");
23233  }
23234  arg4 = reinterpret_cast< uint8_t * >(argp4);
23235  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_char, 0 | 0 );
23236  if (!SWIG_IsOK(res5)) {
23237  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BgpRib6_insert" "', argument " "5"" of type '" "uint8_t const [16]""'");
23238  }
23239  arg5 = reinterpret_cast< uint8_t * >(argp5);
23240  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_libbgp__RouteEventBus, 0 | 0 );
23241  if (!SWIG_IsOK(res6)) {
23242  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BgpRib6_insert" "', argument " "6"" of type '" "libbgp::RouteEventBus *""'");
23243  }
23244  arg6 = reinterpret_cast< libbgp::RouteEventBus * >(argp6);
23245  ecode7 = SWIG_AsVal_int(obj6, &val7);
23246  if (!SWIG_IsOK(ecode7)) {
23247  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BgpRib6_insert" "', argument " "7"" of type '" "int32_t""'");
23248  }
23249  arg7 = static_cast< int32_t >(val7);
23250  result = (arg1)->insert(arg2,(std::vector< libbgp::Prefix6 > const &)*arg3,(uint8_t const (*))arg4,(uint8_t const (*))arg5,arg6,arg7);
23251  resultobj = SWIG_NewPointerObj((new std::vector< libbgp::BgpRib6Entry >(static_cast< const std::vector< libbgp::BgpRib6Entry >& >(result))), SWIGTYPE_p_std__vectorT_libbgp__BgpRib6Entry_t, SWIG_POINTER_OWN | 0 );
23252  return resultobj;
23253 fail:
23254  return NULL;
23255 }
23256 
23257 
23258 SWIGINTERN PyObject *_wrap_BgpRib6_insert__SWIG_7(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23259  PyObject *resultobj = 0;
23260  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
23262  std::vector< libbgp::Prefix6 > *arg3 = 0 ;
23263  uint8_t *arg4 ;
23264  uint8_t *arg5 ;
23266  void *argp1 = 0 ;
23267  int res1 = 0 ;
23268  void *argp2 = 0 ;
23269  int res2 = 0 ;
23270  void *argp3 = 0 ;
23271  int res3 = 0 ;
23272  void *argp4 = 0 ;
23273  int res4 = 0 ;
23274  void *argp5 = 0 ;
23275  int res5 = 0 ;
23276  void *argp6 = 0 ;
23277  int res6 = 0 ;
23278  PyObject * obj0 = 0 ;
23279  PyObject * obj1 = 0 ;
23280  PyObject * obj2 = 0 ;
23281  PyObject * obj3 = 0 ;
23282  PyObject * obj4 = 0 ;
23283  PyObject * obj5 = 0 ;
23284  SwigValueWrapper< std::vector< libbgp::BgpRib6Entry > > result;
23285 
23286  if (!PyArg_ParseTuple(args,(char *)"OOOOOO:BgpRib6_insert",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
23287  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
23288  if (!SWIG_IsOK(res1)) {
23289  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_insert" "', argument " "1"" of type '" "libbgp::BgpRib6 *""'");
23290  }
23291  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
23292  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
23293  if (!SWIG_IsOK(res2)) {
23294  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib6_insert" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
23295  }
23296  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
23297  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0 | 0);
23298  if (!SWIG_IsOK(res3)) {
23299  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
23300  }
23301  if (!argp3) {
23302  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
23303  }
23304  arg3 = reinterpret_cast< std::vector< libbgp::Prefix6 > * >(argp3);
23305  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
23306  if (!SWIG_IsOK(res4)) {
23307  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpRib6_insert" "', argument " "4"" of type '" "uint8_t const [16]""'");
23308  }
23309  arg4 = reinterpret_cast< uint8_t * >(argp4);
23310  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_char, 0 | 0 );
23311  if (!SWIG_IsOK(res5)) {
23312  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BgpRib6_insert" "', argument " "5"" of type '" "uint8_t const [16]""'");
23313  }
23314  arg5 = reinterpret_cast< uint8_t * >(argp5);
23315  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_libbgp__RouteEventBus, 0 | 0 );
23316  if (!SWIG_IsOK(res6)) {
23317  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BgpRib6_insert" "', argument " "6"" of type '" "libbgp::RouteEventBus *""'");
23318  }
23319  arg6 = reinterpret_cast< libbgp::RouteEventBus * >(argp6);
23320  result = (arg1)->insert(arg2,(std::vector< libbgp::Prefix6 > const &)*arg3,(uint8_t const (*))arg4,(uint8_t const (*))arg5,arg6);
23321  resultobj = SWIG_NewPointerObj((new std::vector< libbgp::BgpRib6Entry >(static_cast< const std::vector< libbgp::BgpRib6Entry >& >(result))), SWIGTYPE_p_std__vectorT_libbgp__BgpRib6Entry_t, SWIG_POINTER_OWN | 0 );
23322  return resultobj;
23323 fail:
23324  return NULL;
23325 }
23326 
23327 
23328 SWIGINTERN PyObject *_wrap_BgpRib6_insert__SWIG_8(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23329  PyObject *resultobj = 0;
23330  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
23331  uint32_t arg2 ;
23332  libbgp::Prefix6 *arg3 = 0 ;
23333  uint8_t *arg4 ;
23334  uint8_t *arg5 ;
23335  std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *arg6 = 0 ;
23336  int32_t arg7 ;
23337  void *argp1 = 0 ;
23338  int res1 = 0 ;
23339  unsigned int val2 ;
23340  int ecode2 = 0 ;
23341  void *argp3 = 0 ;
23342  int res3 = 0 ;
23343  void *argp4 = 0 ;
23344  int res4 = 0 ;
23345  void *argp5 = 0 ;
23346  int res5 = 0 ;
23347  void *argp6 = 0 ;
23348  int res6 = 0 ;
23349  int val7 ;
23350  int ecode7 = 0 ;
23351  PyObject * obj0 = 0 ;
23352  PyObject * obj1 = 0 ;
23353  PyObject * obj2 = 0 ;
23354  PyObject * obj3 = 0 ;
23355  PyObject * obj4 = 0 ;
23356  PyObject * obj5 = 0 ;
23357  PyObject * obj6 = 0 ;
23358  bool result;
23359 
23360  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BgpRib6_insert",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23361  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
23362  if (!SWIG_IsOK(res1)) {
23363  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_insert" "', argument " "1"" of type '" "libbgp::BgpRib6 *""'");
23364  }
23365  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
23366  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23367  if (!SWIG_IsOK(ecode2)) {
23368  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib6_insert" "', argument " "2"" of type '" "uint32_t""'");
23369  }
23370  arg2 = static_cast< uint32_t >(val2);
23371  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix6, 0 | 0);
23372  if (!SWIG_IsOK(res3)) {
23373  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "libbgp::Prefix6 const &""'");
23374  }
23375  if (!argp3) {
23376  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "libbgp::Prefix6 const &""'");
23377  }
23378  arg3 = reinterpret_cast< libbgp::Prefix6 * >(argp3);
23379  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
23380  if (!SWIG_IsOK(res4)) {
23381  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpRib6_insert" "', argument " "4"" of type '" "uint8_t const [16]""'");
23382  }
23383  arg4 = reinterpret_cast< uint8_t * >(argp4);
23384  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_char, 0 | 0 );
23385  if (!SWIG_IsOK(res5)) {
23386  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BgpRib6_insert" "', argument " "5"" of type '" "uint8_t const [16]""'");
23387  }
23388  arg5 = reinterpret_cast< uint8_t * >(argp5);
23389  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0 | 0);
23390  if (!SWIG_IsOK(res6)) {
23391  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BgpRib6_insert" "', argument " "6"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &""'");
23392  }
23393  if (!argp6) {
23394  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib6_insert" "', argument " "6"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &""'");
23395  }
23396  arg6 = reinterpret_cast< std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > * >(argp6);
23397  ecode7 = SWIG_AsVal_int(obj6, &val7);
23398  if (!SWIG_IsOK(ecode7)) {
23399  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BgpRib6_insert" "', argument " "7"" of type '" "int32_t""'");
23400  }
23401  arg7 = static_cast< int32_t >(val7);
23402  result = (bool)(arg1)->insert(arg2,(libbgp::Prefix6 const &)*arg3,(uint8_t const (*))arg4,(uint8_t const (*))arg5,(std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &)*arg6,arg7);
23403  resultobj = SWIG_From_bool(static_cast< bool >(result));
23404  return resultobj;
23405 fail:
23406  return NULL;
23407 }
23408 
23409 
23410 SWIGINTERN PyObject *_wrap_BgpRib6_insert__SWIG_9(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23411  PyObject *resultobj = 0;
23412  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
23413  uint32_t arg2 ;
23414  std::vector< libbgp::Prefix6 > *arg3 = 0 ;
23415  uint8_t *arg4 ;
23416  uint8_t *arg5 ;
23417  std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *arg6 = 0 ;
23418  int32_t arg7 ;
23419  void *argp1 = 0 ;
23420  int res1 = 0 ;
23421  unsigned int val2 ;
23422  int ecode2 = 0 ;
23423  void *argp3 = 0 ;
23424  int res3 = 0 ;
23425  void *argp4 = 0 ;
23426  int res4 = 0 ;
23427  void *argp5 = 0 ;
23428  int res5 = 0 ;
23429  void *argp6 = 0 ;
23430  int res6 = 0 ;
23431  int val7 ;
23432  int ecode7 = 0 ;
23433  PyObject * obj0 = 0 ;
23434  PyObject * obj1 = 0 ;
23435  PyObject * obj2 = 0 ;
23436  PyObject * obj3 = 0 ;
23437  PyObject * obj4 = 0 ;
23438  PyObject * obj5 = 0 ;
23439  PyObject * obj6 = 0 ;
23440  ssize_t result;
23441 
23442  if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:BgpRib6_insert",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23443  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
23444  if (!SWIG_IsOK(res1)) {
23445  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_insert" "', argument " "1"" of type '" "libbgp::BgpRib6 *""'");
23446  }
23447  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
23448  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23449  if (!SWIG_IsOK(ecode2)) {
23450  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib6_insert" "', argument " "2"" of type '" "uint32_t""'");
23451  }
23452  arg2 = static_cast< uint32_t >(val2);
23453  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0 | 0);
23454  if (!SWIG_IsOK(res3)) {
23455  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
23456  }
23457  if (!argp3) {
23458  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib6_insert" "', argument " "3"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
23459  }
23460  arg3 = reinterpret_cast< std::vector< libbgp::Prefix6 > * >(argp3);
23461  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
23462  if (!SWIG_IsOK(res4)) {
23463  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpRib6_insert" "', argument " "4"" of type '" "uint8_t const [16]""'");
23464  }
23465  arg4 = reinterpret_cast< uint8_t * >(argp4);
23466  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_char, 0 | 0 );
23467  if (!SWIG_IsOK(res5)) {
23468  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BgpRib6_insert" "', argument " "5"" of type '" "uint8_t const [16]""'");
23469  }
23470  arg5 = reinterpret_cast< uint8_t * >(argp5);
23471  res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0 | 0);
23472  if (!SWIG_IsOK(res6)) {
23473  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BgpRib6_insert" "', argument " "6"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &""'");
23474  }
23475  if (!argp6) {
23476  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib6_insert" "', argument " "6"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &""'");
23477  }
23478  arg6 = reinterpret_cast< std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > * >(argp6);
23479  ecode7 = SWIG_AsVal_int(obj6, &val7);
23480  if (!SWIG_IsOK(ecode7)) {
23481  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BgpRib6_insert" "', argument " "7"" of type '" "int32_t""'");
23482  }
23483  arg7 = static_cast< int32_t >(val7);
23484  result = (arg1)->insert(arg2,(std::vector< libbgp::Prefix6 > const &)*arg3,(uint8_t const (*))arg4,(uint8_t const (*))arg5,(std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &)*arg6,arg7);
23485  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
23486  return resultobj;
23487 fail:
23488  return NULL;
23489 }
23490 
23491 
23492 SWIGINTERN PyObject *_wrap_BgpRib6_insert(PyObject *self, PyObject *args) {
23493  Py_ssize_t argc;
23494  PyObject *argv[8] = {
23495  0
23496  };
23497  Py_ssize_t ii;
23498 
23499  if (!PyTuple_Check(args)) SWIG_fail;
23500  argc = args ? PyObject_Length(args) : 0;
23501  for (ii = 0; (ii < 7) && (ii < argc); ii++) {
23502  argv[ii] = PyTuple_GET_ITEM(args,ii);
23503  }
23504  if (argc == 5) {
23505  int _v;
23506  void *vptr = 0;
23507  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib6, 0);
23508  _v = SWIG_CheckState(res);
23509  if (_v) {
23510  void *vptr = 0;
23511  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
23512  _v = SWIG_CheckState(res);
23513  if (_v) {
23514  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_libbgp__Prefix6, 0);
23515  _v = SWIG_CheckState(res);
23516  if (_v) {
23517  void *vptr = 0;
23518  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
23519  _v = SWIG_CheckState(res);
23520  if (_v) {
23521  void *vptr = 0;
23522  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, 0);
23523  _v = SWIG_CheckState(res);
23524  if (_v) {
23525  return _wrap_BgpRib6_insert__SWIG_1(self, args);
23526  }
23527  }
23528  }
23529  }
23530  }
23531  }
23532  if (argc == 5) {
23533  int _v;
23534  void *vptr = 0;
23535  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib6, 0);
23536  _v = SWIG_CheckState(res);
23537  if (_v) {
23538  void *vptr = 0;
23539  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
23540  _v = SWIG_CheckState(res);
23541  if (_v) {
23542  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0);
23543  _v = SWIG_CheckState(res);
23544  if (_v) {
23545  void *vptr = 0;
23546  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
23547  _v = SWIG_CheckState(res);
23548  if (_v) {
23549  void *vptr = 0;
23550  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, 0);
23551  _v = SWIG_CheckState(res);
23552  if (_v) {
23553  return _wrap_BgpRib6_insert__SWIG_5(self, args);
23554  }
23555  }
23556  }
23557  }
23558  }
23559  }
23560  if (argc == 6) {
23561  int _v;
23562  void *vptr = 0;
23563  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib6, 0);
23564  _v = SWIG_CheckState(res);
23565  if (_v) {
23566  void *vptr = 0;
23567  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
23568  _v = SWIG_CheckState(res);
23569  if (_v) {
23570  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_libbgp__Prefix6, 0);
23571  _v = SWIG_CheckState(res);
23572  if (_v) {
23573  void *vptr = 0;
23574  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
23575  _v = SWIG_CheckState(res);
23576  if (_v) {
23577  void *vptr = 0;
23578  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, 0);
23579  _v = SWIG_CheckState(res);
23580  if (_v) {
23581  void *vptr = 0;
23582  int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_libbgp__RouteEventBus, 0);
23583  _v = SWIG_CheckState(res);
23584  if (_v) {
23585  return _wrap_BgpRib6_insert__SWIG_3(self, args);
23586  }
23587  }
23588  }
23589  }
23590  }
23591  }
23592  }
23593  if (argc == 6) {
23594  int _v;
23595  void *vptr = 0;
23596  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib6, 0);
23597  _v = SWIG_CheckState(res);
23598  if (_v) {
23599  void *vptr = 0;
23600  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
23601  _v = SWIG_CheckState(res);
23602  if (_v) {
23603  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0);
23604  _v = SWIG_CheckState(res);
23605  if (_v) {
23606  void *vptr = 0;
23607  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
23608  _v = SWIG_CheckState(res);
23609  if (_v) {
23610  void *vptr = 0;
23611  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, 0);
23612  _v = SWIG_CheckState(res);
23613  if (_v) {
23614  void *vptr = 0;
23615  int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_libbgp__RouteEventBus, 0);
23616  _v = SWIG_CheckState(res);
23617  if (_v) {
23618  return _wrap_BgpRib6_insert__SWIG_7(self, args);
23619  }
23620  }
23621  }
23622  }
23623  }
23624  }
23625  }
23626  if (argc == 6) {
23627  int _v;
23628  void *vptr = 0;
23629  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib6, 0);
23630  _v = SWIG_CheckState(res);
23631  if (_v) {
23632  void *vptr = 0;
23633  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
23634  _v = SWIG_CheckState(res);
23635  if (_v) {
23636  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_libbgp__Prefix6, 0);
23637  _v = SWIG_CheckState(res);
23638  if (_v) {
23639  void *vptr = 0;
23640  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
23641  _v = SWIG_CheckState(res);
23642  if (_v) {
23643  void *vptr = 0;
23644  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, 0);
23645  _v = SWIG_CheckState(res);
23646  if (_v) {
23647  {
23648  int res = SWIG_AsVal_int(argv[5], NULL);
23649  _v = SWIG_CheckState(res);
23650  }
23651  if (_v) {
23652  return _wrap_BgpRib6_insert__SWIG_0(self, args);
23653  }
23654  }
23655  }
23656  }
23657  }
23658  }
23659  }
23660  if (argc == 6) {
23661  int _v;
23662  void *vptr = 0;
23663  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib6, 0);
23664  _v = SWIG_CheckState(res);
23665  if (_v) {
23666  void *vptr = 0;
23667  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
23668  _v = SWIG_CheckState(res);
23669  if (_v) {
23670  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0);
23671  _v = SWIG_CheckState(res);
23672  if (_v) {
23673  void *vptr = 0;
23674  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
23675  _v = SWIG_CheckState(res);
23676  if (_v) {
23677  void *vptr = 0;
23678  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, 0);
23679  _v = SWIG_CheckState(res);
23680  if (_v) {
23681  {
23682  int res = SWIG_AsVal_int(argv[5], NULL);
23683  _v = SWIG_CheckState(res);
23684  }
23685  if (_v) {
23686  return _wrap_BgpRib6_insert__SWIG_4(self, args);
23687  }
23688  }
23689  }
23690  }
23691  }
23692  }
23693  }
23694  if (argc == 7) {
23695  int _v;
23696  void *vptr = 0;
23697  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib6, 0);
23698  _v = SWIG_CheckState(res);
23699  if (_v) {
23700  void *vptr = 0;
23701  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
23702  _v = SWIG_CheckState(res);
23703  if (_v) {
23704  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0);
23705  _v = SWIG_CheckState(res);
23706  if (_v) {
23707  void *vptr = 0;
23708  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
23709  _v = SWIG_CheckState(res);
23710  if (_v) {
23711  void *vptr = 0;
23712  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, 0);
23713  _v = SWIG_CheckState(res);
23714  if (_v) {
23715  void *vptr = 0;
23716  int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_libbgp__RouteEventBus, 0);
23717  _v = SWIG_CheckState(res);
23718  if (_v) {
23719  {
23720  int res = SWIG_AsVal_int(argv[6], NULL);
23721  _v = SWIG_CheckState(res);
23722  }
23723  if (_v) {
23724  return _wrap_BgpRib6_insert__SWIG_6(self, args);
23725  }
23726  }
23727  }
23728  }
23729  }
23730  }
23731  }
23732  }
23733  if (argc == 7) {
23734  int _v;
23735  void *vptr = 0;
23736  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib6, 0);
23737  _v = SWIG_CheckState(res);
23738  if (_v) {
23739  void *vptr = 0;
23740  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_libbgp__BgpLogHandler, 0);
23741  _v = SWIG_CheckState(res);
23742  if (_v) {
23743  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_libbgp__Prefix6, 0);
23744  _v = SWIG_CheckState(res);
23745  if (_v) {
23746  void *vptr = 0;
23747  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
23748  _v = SWIG_CheckState(res);
23749  if (_v) {
23750  void *vptr = 0;
23751  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, 0);
23752  _v = SWIG_CheckState(res);
23753  if (_v) {
23754  void *vptr = 0;
23755  int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_libbgp__RouteEventBus, 0);
23756  _v = SWIG_CheckState(res);
23757  if (_v) {
23758  {
23759  int res = SWIG_AsVal_int(argv[6], NULL);
23760  _v = SWIG_CheckState(res);
23761  }
23762  if (_v) {
23763  return _wrap_BgpRib6_insert__SWIG_2(self, args);
23764  }
23765  }
23766  }
23767  }
23768  }
23769  }
23770  }
23771  }
23772  if (argc == 7) {
23773  int _v;
23774  void *vptr = 0;
23775  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib6, 0);
23776  _v = SWIG_CheckState(res);
23777  if (_v) {
23778  {
23779  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
23780  _v = SWIG_CheckState(res);
23781  }
23782  if (_v) {
23783  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_libbgp__Prefix6, 0);
23784  _v = SWIG_CheckState(res);
23785  if (_v) {
23786  void *vptr = 0;
23787  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
23788  _v = SWIG_CheckState(res);
23789  if (_v) {
23790  void *vptr = 0;
23791  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, 0);
23792  _v = SWIG_CheckState(res);
23793  if (_v) {
23794  int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0);
23795  _v = SWIG_CheckState(res);
23796  if (_v) {
23797  {
23798  int res = SWIG_AsVal_int(argv[6], NULL);
23799  _v = SWIG_CheckState(res);
23800  }
23801  if (_v) {
23802  return _wrap_BgpRib6_insert__SWIG_8(self, args);
23803  }
23804  }
23805  }
23806  }
23807  }
23808  }
23809  }
23810  }
23811  if (argc == 7) {
23812  int _v;
23813  void *vptr = 0;
23814  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib6, 0);
23815  _v = SWIG_CheckState(res);
23816  if (_v) {
23817  {
23818  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
23819  _v = SWIG_CheckState(res);
23820  }
23821  if (_v) {
23822  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0);
23823  _v = SWIG_CheckState(res);
23824  if (_v) {
23825  void *vptr = 0;
23826  int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
23827  _v = SWIG_CheckState(res);
23828  if (_v) {
23829  void *vptr = 0;
23830  int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_char, 0);
23831  _v = SWIG_CheckState(res);
23832  if (_v) {
23833  int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0);
23834  _v = SWIG_CheckState(res);
23835  if (_v) {
23836  {
23837  int res = SWIG_AsVal_int(argv[6], NULL);
23838  _v = SWIG_CheckState(res);
23839  }
23840  if (_v) {
23841  return _wrap_BgpRib6_insert__SWIG_9(self, args);
23842  }
23843  }
23844  }
23845  }
23846  }
23847  }
23848  }
23849  }
23850 
23851 fail:
23852  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BgpRib6_insert'.\n"
23853  " Possible C/C++ prototypes are:\n"
23854  " libbgp::BgpRib6::insert(libbgp::BgpLogHandler *,libbgp::Prefix6 const &,uint8_t const [16],uint8_t const [16],int32_t)\n"
23855  " libbgp::BgpRib6::insert(libbgp::BgpLogHandler *,libbgp::Prefix6 const &,uint8_t const [16],uint8_t const [16])\n"
23856  " libbgp::BgpRib6::insert(libbgp::BgpLogHandler *,libbgp::Prefix6 const &,uint8_t const [16],uint8_t const [16],libbgp::RouteEventBus *,int32_t)\n"
23857  " libbgp::BgpRib6::insert(libbgp::BgpLogHandler *,libbgp::Prefix6 const &,uint8_t const [16],uint8_t const [16],libbgp::RouteEventBus *)\n"
23858  " libbgp::BgpRib6::insert(libbgp::BgpLogHandler *,std::vector< libbgp::Prefix6 > const &,uint8_t const [16],uint8_t const [16],int32_t)\n"
23859  " libbgp::BgpRib6::insert(libbgp::BgpLogHandler *,std::vector< libbgp::Prefix6 > const &,uint8_t const [16],uint8_t const [16])\n"
23860  " libbgp::BgpRib6::insert(libbgp::BgpLogHandler *,std::vector< libbgp::Prefix6 > const &,uint8_t const [16],uint8_t const [16],libbgp::RouteEventBus *,int32_t)\n"
23861  " libbgp::BgpRib6::insert(libbgp::BgpLogHandler *,std::vector< libbgp::Prefix6 > const &,uint8_t const [16],uint8_t const [16],libbgp::RouteEventBus *)\n"
23862  " libbgp::BgpRib6::insert(uint32_t,libbgp::Prefix6 const &,uint8_t const [16],uint8_t const [16],std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &,int32_t)\n"
23863  " libbgp::BgpRib6::insert(uint32_t,std::vector< libbgp::Prefix6 > const &,uint8_t const [16],uint8_t const [16],std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &,int32_t)\n");
23864  return 0;
23865 }
23866 
23867 
23868 SWIGINTERN PyObject *_wrap_BgpRib6_withdraw__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23869  PyObject *resultobj = 0;
23870  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
23871  uint32_t arg2 ;
23872  libbgp::Prefix6 *arg3 = 0 ;
23873  void *argp1 = 0 ;
23874  int res1 = 0 ;
23875  unsigned int val2 ;
23876  int ecode2 = 0 ;
23877  void *argp3 = 0 ;
23878  int res3 = 0 ;
23879  PyObject * obj0 = 0 ;
23880  PyObject * obj1 = 0 ;
23881  PyObject * obj2 = 0 ;
23882  bool result;
23883 
23884  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpRib6_withdraw",&obj0,&obj1,&obj2)) SWIG_fail;
23885  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
23886  if (!SWIG_IsOK(res1)) {
23887  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_withdraw" "', argument " "1"" of type '" "libbgp::BgpRib6 *""'");
23888  }
23889  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
23890  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23891  if (!SWIG_IsOK(ecode2)) {
23892  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib6_withdraw" "', argument " "2"" of type '" "uint32_t""'");
23893  }
23894  arg2 = static_cast< uint32_t >(val2);
23895  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_libbgp__Prefix6, 0 | 0);
23896  if (!SWIG_IsOK(res3)) {
23897  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib6_withdraw" "', argument " "3"" of type '" "libbgp::Prefix6 const &""'");
23898  }
23899  if (!argp3) {
23900  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib6_withdraw" "', argument " "3"" of type '" "libbgp::Prefix6 const &""'");
23901  }
23902  arg3 = reinterpret_cast< libbgp::Prefix6 * >(argp3);
23903  result = (bool)(arg1)->withdraw(arg2,(libbgp::Prefix6 const &)*arg3);
23904  resultobj = SWIG_From_bool(static_cast< bool >(result));
23905  return resultobj;
23906 fail:
23907  return NULL;
23908 }
23909 
23910 
23911 SWIGINTERN PyObject *_wrap_BgpRib6_withdraw__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23912  PyObject *resultobj = 0;
23913  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
23914  uint32_t arg2 ;
23915  std::vector< libbgp::Prefix6 > *arg3 = 0 ;
23916  void *argp1 = 0 ;
23917  int res1 = 0 ;
23918  unsigned int val2 ;
23919  int ecode2 = 0 ;
23920  void *argp3 = 0 ;
23921  int res3 = 0 ;
23922  PyObject * obj0 = 0 ;
23923  PyObject * obj1 = 0 ;
23924  PyObject * obj2 = 0 ;
23925  ssize_t result;
23926 
23927  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpRib6_withdraw",&obj0,&obj1,&obj2)) SWIG_fail;
23928  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
23929  if (!SWIG_IsOK(res1)) {
23930  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_withdraw" "', argument " "1"" of type '" "libbgp::BgpRib6 *""'");
23931  }
23932  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
23933  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23934  if (!SWIG_IsOK(ecode2)) {
23935  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib6_withdraw" "', argument " "2"" of type '" "uint32_t""'");
23936  }
23937  arg2 = static_cast< uint32_t >(val2);
23938  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0 | 0);
23939  if (!SWIG_IsOK(res3)) {
23940  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib6_withdraw" "', argument " "3"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
23941  }
23942  if (!argp3) {
23943  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpRib6_withdraw" "', argument " "3"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
23944  }
23945  arg3 = reinterpret_cast< std::vector< libbgp::Prefix6 > * >(argp3);
23946  result = (arg1)->withdraw(arg2,(std::vector< libbgp::Prefix6 > const &)*arg3);
23947  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
23948  return resultobj;
23949 fail:
23950  return NULL;
23951 }
23952 
23953 
23954 SWIGINTERN PyObject *_wrap_BgpRib6_withdraw(PyObject *self, PyObject *args) {
23955  Py_ssize_t argc;
23956  PyObject *argv[4] = {
23957  0
23958  };
23959  Py_ssize_t ii;
23960 
23961  if (!PyTuple_Check(args)) SWIG_fail;
23962  argc = args ? PyObject_Length(args) : 0;
23963  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
23964  argv[ii] = PyTuple_GET_ITEM(args,ii);
23965  }
23966  if (argc == 3) {
23967  int _v;
23968  void *vptr = 0;
23969  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib6, 0);
23970  _v = SWIG_CheckState(res);
23971  if (_v) {
23972  {
23973  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
23974  _v = SWIG_CheckState(res);
23975  }
23976  if (_v) {
23977  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_libbgp__Prefix6, 0);
23978  _v = SWIG_CheckState(res);
23979  if (_v) {
23980  return _wrap_BgpRib6_withdraw__SWIG_0(self, args);
23981  }
23982  }
23983  }
23984  }
23985  if (argc == 3) {
23986  int _v;
23987  void *vptr = 0;
23988  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib6, 0);
23989  _v = SWIG_CheckState(res);
23990  if (_v) {
23991  {
23992  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
23993  _v = SWIG_CheckState(res);
23994  }
23995  if (_v) {
23996  int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0);
23997  _v = SWIG_CheckState(res);
23998  if (_v) {
23999  return _wrap_BgpRib6_withdraw__SWIG_1(self, args);
24000  }
24001  }
24002  }
24003  }
24004 
24005 fail:
24006  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BgpRib6_withdraw'.\n"
24007  " Possible C/C++ prototypes are:\n"
24008  " libbgp::BgpRib6::withdraw(uint32_t,libbgp::Prefix6 const &)\n"
24009  " libbgp::BgpRib6::withdraw(uint32_t,std::vector< libbgp::Prefix6 > const &)\n");
24010  return 0;
24011 }
24012 
24013 
24014 SWIGINTERN PyObject *_wrap_BgpRib6_discard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24015  PyObject *resultobj = 0;
24016  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
24017  uint32_t arg2 ;
24018  void *argp1 = 0 ;
24019  int res1 = 0 ;
24020  unsigned int val2 ;
24021  int ecode2 = 0 ;
24022  PyObject * obj0 = 0 ;
24023  PyObject * obj1 = 0 ;
24024  SwigValueWrapper< std::vector< libbgp::Prefix6 > > result;
24025 
24026  if (!PyArg_ParseTuple(args,(char *)"OO:BgpRib6_discard",&obj0,&obj1)) SWIG_fail;
24027  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
24028  if (!SWIG_IsOK(res1)) {
24029  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_discard" "', argument " "1"" of type '" "libbgp::BgpRib6 *""'");
24030  }
24031  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
24032  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24033  if (!SWIG_IsOK(ecode2)) {
24034  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib6_discard" "', argument " "2"" of type '" "uint32_t""'");
24035  }
24036  arg2 = static_cast< uint32_t >(val2);
24037  result = (arg1)->discard(arg2);
24038  resultobj = SWIG_NewPointerObj((new std::vector< libbgp::Prefix6 >(static_cast< const std::vector< libbgp::Prefix6 >& >(result))), SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, SWIG_POINTER_OWN | 0 );
24039  return resultobj;
24040 fail:
24041  return NULL;
24042 }
24043 
24044 
24045 SWIGINTERN PyObject *_wrap_BgpRib6_lookup__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24046  PyObject *resultobj = 0;
24047  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
24048  uint8_t *arg2 ;
24049  void *argp1 = 0 ;
24050  int res1 = 0 ;
24051  void *argp2 = 0 ;
24052  int res2 = 0 ;
24053  PyObject * obj0 = 0 ;
24054  PyObject * obj1 = 0 ;
24055  libbgp::BgpRib6Entry *result = 0 ;
24056 
24057  if (!PyArg_ParseTuple(args,(char *)"OO:BgpRib6_lookup",&obj0,&obj1)) SWIG_fail;
24058  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
24059  if (!SWIG_IsOK(res1)) {
24060  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_lookup" "', argument " "1"" of type '" "libbgp::BgpRib6 const *""'");
24061  }
24062  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
24063  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
24064  if (!SWIG_IsOK(res2)) {
24065  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpRib6_lookup" "', argument " "2"" of type '" "uint8_t const [16]""'");
24066  }
24067  arg2 = reinterpret_cast< uint8_t * >(argp2);
24068  result = (libbgp::BgpRib6Entry *)((libbgp::BgpRib6 const *)arg1)->lookup((uint8_t const (*))arg2);
24069  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib6Entry, 0 | 0 );
24070  return resultobj;
24071 fail:
24072  return NULL;
24073 }
24074 
24075 
24076 SWIGINTERN PyObject *_wrap_BgpRib6_lookup__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24077  PyObject *resultobj = 0;
24078  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
24079  uint32_t arg2 ;
24080  uint8_t *arg3 ;
24081  void *argp1 = 0 ;
24082  int res1 = 0 ;
24083  unsigned int val2 ;
24084  int ecode2 = 0 ;
24085  void *argp3 = 0 ;
24086  int res3 = 0 ;
24087  PyObject * obj0 = 0 ;
24088  PyObject * obj1 = 0 ;
24089  PyObject * obj2 = 0 ;
24090  libbgp::BgpRib6Entry *result = 0 ;
24091 
24092  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpRib6_lookup",&obj0,&obj1,&obj2)) SWIG_fail;
24093  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
24094  if (!SWIG_IsOK(res1)) {
24095  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_lookup" "', argument " "1"" of type '" "libbgp::BgpRib6 const *""'");
24096  }
24097  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
24098  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24099  if (!SWIG_IsOK(ecode2)) {
24100  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpRib6_lookup" "', argument " "2"" of type '" "uint32_t""'");
24101  }
24102  arg2 = static_cast< uint32_t >(val2);
24103  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 );
24104  if (!SWIG_IsOK(res3)) {
24105  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpRib6_lookup" "', argument " "3"" of type '" "uint8_t const [16]""'");
24106  }
24107  arg3 = reinterpret_cast< uint8_t * >(argp3);
24108  result = (libbgp::BgpRib6Entry *)((libbgp::BgpRib6 const *)arg1)->lookup(arg2,(uint8_t const (*))arg3);
24109  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpRib6Entry, 0 | 0 );
24110  return resultobj;
24111 fail:
24112  return NULL;
24113 }
24114 
24115 
24116 SWIGINTERN PyObject *_wrap_BgpRib6_lookup(PyObject *self, PyObject *args) {
24117  Py_ssize_t argc;
24118  PyObject *argv[4] = {
24119  0
24120  };
24121  Py_ssize_t ii;
24122 
24123  if (!PyTuple_Check(args)) SWIG_fail;
24124  argc = args ? PyObject_Length(args) : 0;
24125  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
24126  argv[ii] = PyTuple_GET_ITEM(args,ii);
24127  }
24128  if (argc == 2) {
24129  int _v;
24130  void *vptr = 0;
24131  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib6, 0);
24132  _v = SWIG_CheckState(res);
24133  if (_v) {
24134  void *vptr = 0;
24135  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
24136  _v = SWIG_CheckState(res);
24137  if (_v) {
24138  return _wrap_BgpRib6_lookup__SWIG_0(self, args);
24139  }
24140  }
24141  }
24142  if (argc == 3) {
24143  int _v;
24144  void *vptr = 0;
24145  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpRib6, 0);
24146  _v = SWIG_CheckState(res);
24147  if (_v) {
24148  {
24149  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
24150  _v = SWIG_CheckState(res);
24151  }
24152  if (_v) {
24153  void *vptr = 0;
24154  int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0);
24155  _v = SWIG_CheckState(res);
24156  if (_v) {
24157  return _wrap_BgpRib6_lookup__SWIG_1(self, args);
24158  }
24159  }
24160  }
24161  }
24162 
24163 fail:
24164  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BgpRib6_lookup'.\n"
24165  " Possible C/C++ prototypes are:\n"
24166  " libbgp::BgpRib6::lookup(uint8_t const [16]) const\n"
24167  " libbgp::BgpRib6::lookup(uint32_t,uint8_t const [16]) const\n");
24168  return 0;
24169 }
24170 
24171 
24172 SWIGINTERN PyObject *_wrap_BgpRib6_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24173  PyObject *resultobj = 0;
24174  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
24175  void *argp1 = 0 ;
24176  int res1 = 0 ;
24177  PyObject * obj0 = 0 ;
24178  std::vector< libbgp::BgpRib6Entry > *result = 0 ;
24179 
24180  if (!PyArg_ParseTuple(args,(char *)"O:BgpRib6_get",&obj0)) SWIG_fail;
24181  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, 0 | 0 );
24182  if (!SWIG_IsOK(res1)) {
24183  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpRib6_get" "', argument " "1"" of type '" "libbgp::BgpRib6 const *""'");
24184  }
24185  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
24186  result = (std::vector< libbgp::BgpRib6Entry > *) &((libbgp::BgpRib6 const *)arg1)->get();
24187  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_libbgp__BgpRib6Entry_t, 0 | 0 );
24188  return resultobj;
24189 fail:
24190  return NULL;
24191 }
24192 
24193 
24194 SWIGINTERN PyObject *_wrap_delete_BgpRib6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24195  PyObject *resultobj = 0;
24196  libbgp::BgpRib6 *arg1 = (libbgp::BgpRib6 *) 0 ;
24197  void *argp1 = 0 ;
24198  int res1 = 0 ;
24199  PyObject * obj0 = 0 ;
24200 
24201  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpRib6",&obj0)) SWIG_fail;
24202  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpRib6, SWIG_POINTER_DISOWN | 0 );
24203  if (!SWIG_IsOK(res1)) {
24204  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpRib6" "', argument " "1"" of type '" "libbgp::BgpRib6 *""'");
24205  }
24206  arg1 = reinterpret_cast< libbgp::BgpRib6 * >(argp1);
24207  delete arg1;
24208  resultobj = SWIG_Py_Void();
24209  return resultobj;
24210 fail:
24211  return NULL;
24212 }
24213 
24214 
24215 SWIGINTERN PyObject *BgpRib6_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24216  PyObject *obj;
24217  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
24218  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpRib6, SWIG_NewClientData(obj));
24219  return SWIG_Py_Void();
24220 }
24221 
24222 SWIGINTERN PyObject *_wrap_new_BgpSink(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24223  PyObject *resultobj = 0;
24224  bool arg1 ;
24225  bool val1 ;
24226  int ecode1 = 0 ;
24227  PyObject * obj0 = 0 ;
24228  libbgp::BgpSink *result = 0 ;
24229 
24230  if (!PyArg_ParseTuple(args,(char *)"O:new_BgpSink",&obj0)) SWIG_fail;
24231  ecode1 = SWIG_AsVal_bool(obj0, &val1);
24232  if (!SWIG_IsOK(ecode1)) {
24233  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BgpSink" "', argument " "1"" of type '" "bool""'");
24234  }
24235  arg1 = static_cast< bool >(val1);
24236  result = (libbgp::BgpSink *)new libbgp::BgpSink(arg1);
24237  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpSink, SWIG_POINTER_NEW | 0 );
24238  return resultobj;
24239 fail:
24240  return NULL;
24241 }
24242 
24243 
24244 SWIGINTERN PyObject *_wrap_BgpSink_fill(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24245  PyObject *resultobj = 0;
24246  libbgp::BgpSink *arg1 = (libbgp::BgpSink *) 0 ;
24247  uint8_t *arg2 = (uint8_t *) 0 ;
24248  size_t arg3 ;
24249  void *argp1 = 0 ;
24250  int res1 = 0 ;
24251  void *argp2 = 0 ;
24252  int res2 = 0 ;
24253  size_t val3 ;
24254  int ecode3 = 0 ;
24255  PyObject * obj0 = 0 ;
24256  PyObject * obj1 = 0 ;
24257  PyObject * obj2 = 0 ;
24258  ssize_t result;
24259 
24260  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpSink_fill",&obj0,&obj1,&obj2)) SWIG_fail;
24261  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpSink, 0 | 0 );
24262  if (!SWIG_IsOK(res1)) {
24263  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpSink_fill" "', argument " "1"" of type '" "libbgp::BgpSink *""'");
24264  }
24265  arg1 = reinterpret_cast< libbgp::BgpSink * >(argp1);
24266  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
24267  if (!SWIG_IsOK(res2)) {
24268  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpSink_fill" "', argument " "2"" of type '" "uint8_t const *""'");
24269  }
24270  arg2 = reinterpret_cast< uint8_t * >(argp2);
24271  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
24272  if (!SWIG_IsOK(ecode3)) {
24273  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpSink_fill" "', argument " "3"" of type '" "size_t""'");
24274  }
24275  arg3 = static_cast< size_t >(val3);
24276  result = (arg1)->fill((uint8_t const *)arg2,arg3);
24277  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
24278  return resultobj;
24279 fail:
24280  return NULL;
24281 }
24282 
24283 
24284 SWIGINTERN PyObject *_wrap_BgpSink_pour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24285  PyObject *resultobj = 0;
24286  libbgp::BgpSink *arg1 = (libbgp::BgpSink *) 0 ;
24287  libbgp::BgpPacket **arg2 = (libbgp::BgpPacket **) 0 ;
24288  void *argp1 = 0 ;
24289  int res1 = 0 ;
24290  void *argp2 = 0 ;
24291  int res2 = 0 ;
24292  PyObject * obj0 = 0 ;
24293  PyObject * obj1 = 0 ;
24294  ssize_t result;
24295 
24296  if (!PyArg_ParseTuple(args,(char *)"OO:BgpSink_pour",&obj0,&obj1)) SWIG_fail;
24297  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpSink, 0 | 0 );
24298  if (!SWIG_IsOK(res1)) {
24299  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpSink_pour" "', argument " "1"" of type '" "libbgp::BgpSink *""'");
24300  }
24301  arg1 = reinterpret_cast< libbgp::BgpSink * >(argp1);
24302  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_libbgp__BgpPacket, 0 | 0 );
24303  if (!SWIG_IsOK(res2)) {
24304  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpSink_pour" "', argument " "2"" of type '" "libbgp::BgpPacket **""'");
24305  }
24306  arg2 = reinterpret_cast< libbgp::BgpPacket ** >(argp2);
24307  result = (arg1)->pour(arg2);
24308  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
24309  return resultobj;
24310 fail:
24311  return NULL;
24312 }
24313 
24314 
24315 SWIGINTERN PyObject *_wrap_BgpSink_getBytesInSink(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24316  PyObject *resultobj = 0;
24317  libbgp::BgpSink *arg1 = (libbgp::BgpSink *) 0 ;
24318  void *argp1 = 0 ;
24319  int res1 = 0 ;
24320  PyObject * obj0 = 0 ;
24321  size_t result;
24322 
24323  if (!PyArg_ParseTuple(args,(char *)"O:BgpSink_getBytesInSink",&obj0)) SWIG_fail;
24324  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpSink, 0 | 0 );
24325  if (!SWIG_IsOK(res1)) {
24326  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpSink_getBytesInSink" "', argument " "1"" of type '" "libbgp::BgpSink const *""'");
24327  }
24328  arg1 = reinterpret_cast< libbgp::BgpSink * >(argp1);
24329  result = ((libbgp::BgpSink const *)arg1)->getBytesInSink();
24330  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
24331  return resultobj;
24332 fail:
24333  return NULL;
24334 }
24335 
24336 
24337 SWIGINTERN PyObject *_wrap_BgpSink_drain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24338  PyObject *resultobj = 0;
24339  libbgp::BgpSink *arg1 = (libbgp::BgpSink *) 0 ;
24340  void *argp1 = 0 ;
24341  int res1 = 0 ;
24342  PyObject * obj0 = 0 ;
24343 
24344  if (!PyArg_ParseTuple(args,(char *)"O:BgpSink_drain",&obj0)) SWIG_fail;
24345  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpSink, 0 | 0 );
24346  if (!SWIG_IsOK(res1)) {
24347  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpSink_drain" "', argument " "1"" of type '" "libbgp::BgpSink *""'");
24348  }
24349  arg1 = reinterpret_cast< libbgp::BgpSink * >(argp1);
24350  (arg1)->drain();
24351  resultobj = SWIG_Py_Void();
24352  return resultobj;
24353 fail:
24354  return NULL;
24355 }
24356 
24357 
24358 SWIGINTERN PyObject *_wrap_BgpSink_setLogger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24359  PyObject *resultobj = 0;
24360  libbgp::BgpSink *arg1 = (libbgp::BgpSink *) 0 ;
24362  void *argp1 = 0 ;
24363  int res1 = 0 ;
24364  void *argp2 = 0 ;
24365  int res2 = 0 ;
24366  PyObject * obj0 = 0 ;
24367  PyObject * obj1 = 0 ;
24368 
24369  if (!PyArg_ParseTuple(args,(char *)"OO:BgpSink_setLogger",&obj0,&obj1)) SWIG_fail;
24370  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpSink, 0 | 0 );
24371  if (!SWIG_IsOK(res1)) {
24372  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpSink_setLogger" "', argument " "1"" of type '" "libbgp::BgpSink *""'");
24373  }
24374  arg1 = reinterpret_cast< libbgp::BgpSink * >(argp1);
24375  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
24376  if (!SWIG_IsOK(res2)) {
24377  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpSink_setLogger" "', argument " "2"" of type '" "libbgp::BgpLogHandler *""'");
24378  }
24379  arg2 = reinterpret_cast< libbgp::BgpLogHandler * >(argp2);
24380  (arg1)->setLogger(arg2);
24381  resultobj = SWIG_Py_Void();
24382  return resultobj;
24383 fail:
24384  return NULL;
24385 }
24386 
24387 
24388 SWIGINTERN PyObject *_wrap_delete_BgpSink(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24389  PyObject *resultobj = 0;
24390  libbgp::BgpSink *arg1 = (libbgp::BgpSink *) 0 ;
24391  void *argp1 = 0 ;
24392  int res1 = 0 ;
24393  PyObject * obj0 = 0 ;
24394 
24395  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpSink",&obj0)) SWIG_fail;
24396  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpSink, SWIG_POINTER_DISOWN | 0 );
24397  if (!SWIG_IsOK(res1)) {
24398  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpSink" "', argument " "1"" of type '" "libbgp::BgpSink *""'");
24399  }
24400  arg1 = reinterpret_cast< libbgp::BgpSink * >(argp1);
24401  delete arg1;
24402  resultobj = SWIG_Py_Void();
24403  return resultobj;
24404 fail:
24405  return NULL;
24406 }
24407 
24408 
24409 SWIGINTERN PyObject *BgpSink_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24410  PyObject *obj;
24411  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
24412  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpSink, SWIG_NewClientData(obj));
24413  return SWIG_Py_Void();
24414 }
24415 
24416 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_withdrawn_routes_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24417  PyObject *resultobj = 0;
24419  std::vector< libbgp::Prefix4 > *arg2 = (std::vector< libbgp::Prefix4 > *) 0 ;
24420  void *argp1 = 0 ;
24421  int res1 = 0 ;
24422  void *argp2 = 0 ;
24423  int res2 = 0 ;
24424  PyObject * obj0 = 0 ;
24425  PyObject * obj1 = 0 ;
24426 
24427  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_withdrawn_routes_set",&obj0,&obj1)) SWIG_fail;
24428  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24429  if (!SWIG_IsOK(res1)) {
24430  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_withdrawn_routes_set" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24431  }
24432  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24433  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0 | 0 );
24434  if (!SWIG_IsOK(res2)) {
24435  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpUpdateMessage_withdrawn_routes_set" "', argument " "2"" of type '" "std::vector< libbgp::Prefix4 > *""'");
24436  }
24437  arg2 = reinterpret_cast< std::vector< libbgp::Prefix4 > * >(argp2);
24438  if (arg1) (arg1)->withdrawn_routes = *arg2;
24439  resultobj = SWIG_Py_Void();
24440  return resultobj;
24441 fail:
24442  return NULL;
24443 }
24444 
24445 
24446 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_withdrawn_routes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24447  PyObject *resultobj = 0;
24449  void *argp1 = 0 ;
24450  int res1 = 0 ;
24451  PyObject * obj0 = 0 ;
24452  std::vector< libbgp::Prefix4 > *result = 0 ;
24453 
24454  if (!PyArg_ParseTuple(args,(char *)"O:BgpUpdateMessage_withdrawn_routes_get",&obj0)) SWIG_fail;
24455  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24456  if (!SWIG_IsOK(res1)) {
24457  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_withdrawn_routes_get" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24458  }
24459  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24460  result = (std::vector< libbgp::Prefix4 > *)& ((arg1)->withdrawn_routes);
24461  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0 | 0 );
24462  return resultobj;
24463 fail:
24464  return NULL;
24465 }
24466 
24467 
24468 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_path_attribute_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24469  PyObject *resultobj = 0;
24471  std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *arg2 = (std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *) 0 ;
24472  void *argp1 = 0 ;
24473  int res1 = 0 ;
24474  void *argp2 = 0 ;
24475  int res2 = 0 ;
24476  PyObject * obj0 = 0 ;
24477  PyObject * obj1 = 0 ;
24478 
24479  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_path_attribute_set",&obj0,&obj1)) SWIG_fail;
24480  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24481  if (!SWIG_IsOK(res1)) {
24482  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_path_attribute_set" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24483  }
24484  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24485  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0 | 0 );
24486  if (!SWIG_IsOK(res2)) {
24487  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpUpdateMessage_path_attribute_set" "', argument " "2"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *""'");
24488  }
24489  arg2 = reinterpret_cast< std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > * >(argp2);
24490  if (arg1) (arg1)->path_attribute = *arg2;
24491  resultobj = SWIG_Py_Void();
24492  return resultobj;
24493 fail:
24494  return NULL;
24495 }
24496 
24497 
24498 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_path_attribute_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24499  PyObject *resultobj = 0;
24501  void *argp1 = 0 ;
24502  int res1 = 0 ;
24503  PyObject * obj0 = 0 ;
24504  std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *result = 0 ;
24505 
24506  if (!PyArg_ParseTuple(args,(char *)"O:BgpUpdateMessage_path_attribute_get",&obj0)) SWIG_fail;
24507  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24508  if (!SWIG_IsOK(res1)) {
24509  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_path_attribute_get" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24510  }
24511  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24512  result = (std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *)& ((arg1)->path_attribute);
24513  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0 | 0 );
24514  return resultobj;
24515 fail:
24516  return NULL;
24517 }
24518 
24519 
24520 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_nlri_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24521  PyObject *resultobj = 0;
24523  std::vector< libbgp::Prefix4 > *arg2 = (std::vector< libbgp::Prefix4 > *) 0 ;
24524  void *argp1 = 0 ;
24525  int res1 = 0 ;
24526  void *argp2 = 0 ;
24527  int res2 = 0 ;
24528  PyObject * obj0 = 0 ;
24529  PyObject * obj1 = 0 ;
24530 
24531  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_nlri_set",&obj0,&obj1)) SWIG_fail;
24532  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24533  if (!SWIG_IsOK(res1)) {
24534  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_nlri_set" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24535  }
24536  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24537  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0 | 0 );
24538  if (!SWIG_IsOK(res2)) {
24539  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpUpdateMessage_nlri_set" "', argument " "2"" of type '" "std::vector< libbgp::Prefix4 > *""'");
24540  }
24541  arg2 = reinterpret_cast< std::vector< libbgp::Prefix4 > * >(argp2);
24542  if (arg1) (arg1)->nlri = *arg2;
24543  resultobj = SWIG_Py_Void();
24544  return resultobj;
24545 fail:
24546  return NULL;
24547 }
24548 
24549 
24550 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_nlri_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24551  PyObject *resultobj = 0;
24553  void *argp1 = 0 ;
24554  int res1 = 0 ;
24555  PyObject * obj0 = 0 ;
24556  std::vector< libbgp::Prefix4 > *result = 0 ;
24557 
24558  if (!PyArg_ParseTuple(args,(char *)"O:BgpUpdateMessage_nlri_get",&obj0)) SWIG_fail;
24559  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24560  if (!SWIG_IsOK(res1)) {
24561  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_nlri_get" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24562  }
24563  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24564  result = (std::vector< libbgp::Prefix4 > *)& ((arg1)->nlri);
24565  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0 | 0 );
24566  return resultobj;
24567 fail:
24568  return NULL;
24569 }
24570 
24571 
24572 SWIGINTERN PyObject *_wrap_new_BgpUpdateMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24573  PyObject *resultobj = 0;
24575  bool arg2 ;
24576  void *argp1 = 0 ;
24577  int res1 = 0 ;
24578  bool val2 ;
24579  int ecode2 = 0 ;
24580  PyObject * obj0 = 0 ;
24581  PyObject * obj1 = 0 ;
24582  libbgp::BgpUpdateMessage *result = 0 ;
24583 
24584  if (!PyArg_ParseTuple(args,(char *)"OO:new_BgpUpdateMessage",&obj0,&obj1)) SWIG_fail;
24585  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpLogHandler, 0 | 0 );
24586  if (!SWIG_IsOK(res1)) {
24587  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BgpUpdateMessage" "', argument " "1"" of type '" "libbgp::BgpLogHandler *""'");
24588  }
24589  arg1 = reinterpret_cast< libbgp::BgpLogHandler * >(argp1);
24590  ecode2 = SWIG_AsVal_bool(obj1, &val2);
24591  if (!SWIG_IsOK(ecode2)) {
24592  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BgpUpdateMessage" "', argument " "2"" of type '" "bool""'");
24593  }
24594  arg2 = static_cast< bool >(val2);
24595  result = (libbgp::BgpUpdateMessage *)new libbgp::BgpUpdateMessage(arg1,arg2);
24596  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpUpdateMessage, SWIG_POINTER_NEW | 0 );
24597  return resultobj;
24598 fail:
24599  return NULL;
24600 }
24601 
24602 
24603 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_getAttrib__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24604  PyObject *resultobj = 0;
24606  uint8_t arg2 ;
24607  void *argp1 = 0 ;
24608  int res1 = 0 ;
24609  unsigned char val2 ;
24610  int ecode2 = 0 ;
24611  PyObject * obj0 = 0 ;
24612  PyObject * obj1 = 0 ;
24613  libbgp::BgpPathAttrib *result = 0 ;
24614 
24615  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_getAttrib",&obj0,&obj1)) SWIG_fail;
24616  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24617  if (!SWIG_IsOK(res1)) {
24618  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_getAttrib" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24619  }
24620  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24621  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
24622  if (!SWIG_IsOK(ecode2)) {
24623  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpUpdateMessage_getAttrib" "', argument " "2"" of type '" "uint8_t""'");
24624  }
24625  arg2 = static_cast< uint8_t >(val2);
24626  result = (libbgp::BgpPathAttrib *) &(arg1)->getAttrib(arg2);
24627  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
24628  return resultobj;
24629 fail:
24630  return NULL;
24631 }
24632 
24633 
24634 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_getAttrib__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24635  PyObject *resultobj = 0;
24637  uint8_t arg2 ;
24638  void *argp1 = 0 ;
24639  int res1 = 0 ;
24640  unsigned char val2 ;
24641  int ecode2 = 0 ;
24642  PyObject * obj0 = 0 ;
24643  PyObject * obj1 = 0 ;
24644  libbgp::BgpPathAttrib *result = 0 ;
24645 
24646  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_getAttrib",&obj0,&obj1)) SWIG_fail;
24647  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24648  if (!SWIG_IsOK(res1)) {
24649  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_getAttrib" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage const *""'");
24650  }
24651  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24652  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
24653  if (!SWIG_IsOK(ecode2)) {
24654  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpUpdateMessage_getAttrib" "', argument " "2"" of type '" "uint8_t""'");
24655  }
24656  arg2 = static_cast< uint8_t >(val2);
24657  result = (libbgp::BgpPathAttrib *) &((libbgp::BgpUpdateMessage const *)arg1)->getAttrib(arg2);
24658  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0 );
24659  return resultobj;
24660 fail:
24661  return NULL;
24662 }
24663 
24664 
24665 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_getAttrib(PyObject *self, PyObject *args) {
24666  Py_ssize_t argc;
24667  PyObject *argv[3] = {
24668  0
24669  };
24670  Py_ssize_t ii;
24671 
24672  if (!PyTuple_Check(args)) SWIG_fail;
24673  argc = args ? PyObject_Length(args) : 0;
24674  for (ii = 0; (ii < 2) && (ii < argc); ii++) {
24675  argv[ii] = PyTuple_GET_ITEM(args,ii);
24676  }
24677  if (argc == 2) {
24678  int _v;
24679  void *vptr = 0;
24680  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpUpdateMessage, 0);
24681  _v = SWIG_CheckState(res);
24682  if (_v) {
24683  {
24684  int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
24685  _v = SWIG_CheckState(res);
24686  }
24687  if (_v) {
24688  return _wrap_BgpUpdateMessage_getAttrib__SWIG_0(self, args);
24689  }
24690  }
24691  }
24692  if (argc == 2) {
24693  int _v;
24694  void *vptr = 0;
24695  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpUpdateMessage, 0);
24696  _v = SWIG_CheckState(res);
24697  if (_v) {
24698  {
24699  int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
24700  _v = SWIG_CheckState(res);
24701  }
24702  if (_v) {
24703  return _wrap_BgpUpdateMessage_getAttrib__SWIG_1(self, args);
24704  }
24705  }
24706  }
24707 
24708 fail:
24709  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BgpUpdateMessage_getAttrib'.\n"
24710  " Possible C/C++ prototypes are:\n"
24711  " libbgp::BgpUpdateMessage::getAttrib(uint8_t)\n"
24712  " libbgp::BgpUpdateMessage::getAttrib(uint8_t) const\n");
24713  return 0;
24714 }
24715 
24716 
24717 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_hasAttrib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24718  PyObject *resultobj = 0;
24720  uint8_t arg2 ;
24721  void *argp1 = 0 ;
24722  int res1 = 0 ;
24723  unsigned char val2 ;
24724  int ecode2 = 0 ;
24725  PyObject * obj0 = 0 ;
24726  PyObject * obj1 = 0 ;
24727  bool result;
24728 
24729  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_hasAttrib",&obj0,&obj1)) SWIG_fail;
24730  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24731  if (!SWIG_IsOK(res1)) {
24732  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_hasAttrib" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage const *""'");
24733  }
24734  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24735  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
24736  if (!SWIG_IsOK(ecode2)) {
24737  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpUpdateMessage_hasAttrib" "', argument " "2"" of type '" "uint8_t""'");
24738  }
24739  arg2 = static_cast< uint8_t >(val2);
24740  result = (bool)((libbgp::BgpUpdateMessage const *)arg1)->hasAttrib(arg2);
24741  resultobj = SWIG_From_bool(static_cast< bool >(result));
24742  return resultobj;
24743 fail:
24744  return NULL;
24745 }
24746 
24747 
24748 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_addAttrib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24749  PyObject *resultobj = 0;
24751  libbgp::BgpPathAttrib *arg2 = 0 ;
24752  void *argp1 = 0 ;
24753  int res1 = 0 ;
24754  void *argp2 = 0 ;
24755  int res2 = 0 ;
24756  PyObject * obj0 = 0 ;
24757  PyObject * obj1 = 0 ;
24758  bool result;
24759 
24760  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_addAttrib",&obj0,&obj1)) SWIG_fail;
24761  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24762  if (!SWIG_IsOK(res1)) {
24763  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_addAttrib" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24764  }
24765  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24766  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0);
24767  if (!SWIG_IsOK(res2)) {
24768  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpUpdateMessage_addAttrib" "', argument " "2"" of type '" "libbgp::BgpPathAttrib const &""'");
24769  }
24770  if (!argp2) {
24771  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpUpdateMessage_addAttrib" "', argument " "2"" of type '" "libbgp::BgpPathAttrib const &""'");
24772  }
24773  arg2 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp2);
24774  result = (bool)(arg1)->addAttrib((libbgp::BgpPathAttrib const &)*arg2);
24775  resultobj = SWIG_From_bool(static_cast< bool >(result));
24776  return resultobj;
24777 fail:
24778  return NULL;
24779 }
24780 
24781 
24782 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_setAttribs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24783  PyObject *resultobj = 0;
24785  std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *arg2 = 0 ;
24786  void *argp1 = 0 ;
24787  int res1 = 0 ;
24788  void *argp2 = 0 ;
24789  int res2 = 0 ;
24790  PyObject * obj0 = 0 ;
24791  PyObject * obj1 = 0 ;
24792  bool result;
24793 
24794  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_setAttribs",&obj0,&obj1)) SWIG_fail;
24795  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24796  if (!SWIG_IsOK(res1)) {
24797  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_setAttribs" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24798  }
24799  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24800  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0 | 0);
24801  if (!SWIG_IsOK(res2)) {
24802  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpUpdateMessage_setAttribs" "', argument " "2"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &""'");
24803  }
24804  if (!argp2) {
24805  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpUpdateMessage_setAttribs" "', argument " "2"" of type '" "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &""'");
24806  }
24807  arg2 = reinterpret_cast< std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > * >(argp2);
24808  result = (bool)(arg1)->setAttribs((std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > const &)*arg2);
24809  resultobj = SWIG_From_bool(static_cast< bool >(result));
24810  return resultobj;
24811 fail:
24812  return NULL;
24813 }
24814 
24815 
24816 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_dropAttrib(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24817  PyObject *resultobj = 0;
24819  uint8_t arg2 ;
24820  void *argp1 = 0 ;
24821  int res1 = 0 ;
24822  unsigned char val2 ;
24823  int ecode2 = 0 ;
24824  PyObject * obj0 = 0 ;
24825  PyObject * obj1 = 0 ;
24826  bool result;
24827 
24828  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_dropAttrib",&obj0,&obj1)) SWIG_fail;
24829  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24830  if (!SWIG_IsOK(res1)) {
24831  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_dropAttrib" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24832  }
24833  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24834  ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
24835  if (!SWIG_IsOK(ecode2)) {
24836  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpUpdateMessage_dropAttrib" "', argument " "2"" of type '" "uint8_t""'");
24837  }
24838  arg2 = static_cast< uint8_t >(val2);
24839  result = (bool)(arg1)->dropAttrib(arg2);
24840  resultobj = SWIG_From_bool(static_cast< bool >(result));
24841  return resultobj;
24842 fail:
24843  return NULL;
24844 }
24845 
24846 
24847 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_updateAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24848  PyObject *resultobj = 0;
24850  libbgp::BgpPathAttrib *arg2 = 0 ;
24851  void *argp1 = 0 ;
24852  int res1 = 0 ;
24853  void *argp2 = 0 ;
24854  int res2 = 0 ;
24855  PyObject * obj0 = 0 ;
24856  PyObject * obj1 = 0 ;
24857  bool result;
24858 
24859  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_updateAttribute",&obj0,&obj1)) SWIG_fail;
24860  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24861  if (!SWIG_IsOK(res1)) {
24862  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_updateAttribute" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24863  }
24864  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24865  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__BgpPathAttrib, 0 | 0);
24866  if (!SWIG_IsOK(res2)) {
24867  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpUpdateMessage_updateAttribute" "', argument " "2"" of type '" "libbgp::BgpPathAttrib const &""'");
24868  }
24869  if (!argp2) {
24870  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpUpdateMessage_updateAttribute" "', argument " "2"" of type '" "libbgp::BgpPathAttrib const &""'");
24871  }
24872  arg2 = reinterpret_cast< libbgp::BgpPathAttrib * >(argp2);
24873  result = (bool)(arg1)->updateAttribute((libbgp::BgpPathAttrib const &)*arg2);
24874  resultobj = SWIG_From_bool(static_cast< bool >(result));
24875  return resultobj;
24876 fail:
24877  return NULL;
24878 }
24879 
24880 
24881 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_dropNonTransitive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24882  PyObject *resultobj = 0;
24884  void *argp1 = 0 ;
24885  int res1 = 0 ;
24886  PyObject * obj0 = 0 ;
24887  bool result;
24888 
24889  if (!PyArg_ParseTuple(args,(char *)"O:BgpUpdateMessage_dropNonTransitive",&obj0)) SWIG_fail;
24890  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24891  if (!SWIG_IsOK(res1)) {
24892  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_dropNonTransitive" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24893  }
24894  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24895  result = (bool)(arg1)->dropNonTransitive();
24896  resultobj = SWIG_From_bool(static_cast< bool >(result));
24897  return resultobj;
24898 fail:
24899  return NULL;
24900 }
24901 
24902 
24903 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_setNextHop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24904  PyObject *resultobj = 0;
24906  uint32_t arg2 ;
24907  void *argp1 = 0 ;
24908  int res1 = 0 ;
24909  unsigned int val2 ;
24910  int ecode2 = 0 ;
24911  PyObject * obj0 = 0 ;
24912  PyObject * obj1 = 0 ;
24913  bool result;
24914 
24915  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_setNextHop",&obj0,&obj1)) SWIG_fail;
24916  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24917  if (!SWIG_IsOK(res1)) {
24918  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_setNextHop" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24919  }
24920  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24921  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24922  if (!SWIG_IsOK(ecode2)) {
24923  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpUpdateMessage_setNextHop" "', argument " "2"" of type '" "uint32_t""'");
24924  }
24925  arg2 = static_cast< uint32_t >(val2);
24926  result = (bool)(arg1)->setNextHop(arg2);
24927  resultobj = SWIG_From_bool(static_cast< bool >(result));
24928  return resultobj;
24929 fail:
24930  return NULL;
24931 }
24932 
24933 
24934 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24935  PyObject *resultobj = 0;
24937  uint32_t arg2 ;
24938  void *argp1 = 0 ;
24939  int res1 = 0 ;
24940  unsigned int val2 ;
24941  int ecode2 = 0 ;
24942  PyObject * obj0 = 0 ;
24943  PyObject * obj1 = 0 ;
24944  bool result;
24945 
24946  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_prepend",&obj0,&obj1)) SWIG_fail;
24947  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24948  if (!SWIG_IsOK(res1)) {
24949  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_prepend" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24950  }
24951  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24952  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24953  if (!SWIG_IsOK(ecode2)) {
24954  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpUpdateMessage_prepend" "', argument " "2"" of type '" "uint32_t""'");
24955  }
24956  arg2 = static_cast< uint32_t >(val2);
24957  result = (bool)(arg1)->prepend(arg2);
24958  resultobj = SWIG_From_bool(static_cast< bool >(result));
24959  return resultobj;
24960 fail:
24961  return NULL;
24962 }
24963 
24964 
24965 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_restoreAsPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24966  PyObject *resultobj = 0;
24968  void *argp1 = 0 ;
24969  int res1 = 0 ;
24970  PyObject * obj0 = 0 ;
24971  bool result;
24972 
24973  if (!PyArg_ParseTuple(args,(char *)"O:BgpUpdateMessage_restoreAsPath",&obj0)) SWIG_fail;
24974  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24975  if (!SWIG_IsOK(res1)) {
24976  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_restoreAsPath" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24977  }
24978  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
24979  result = (bool)(arg1)->restoreAsPath();
24980  resultobj = SWIG_From_bool(static_cast< bool >(result));
24981  return resultobj;
24982 fail:
24983  return NULL;
24984 }
24985 
24986 
24987 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_downgradeAsPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24988  PyObject *resultobj = 0;
24990  void *argp1 = 0 ;
24991  int res1 = 0 ;
24992  PyObject * obj0 = 0 ;
24993  bool result;
24994 
24995  if (!PyArg_ParseTuple(args,(char *)"O:BgpUpdateMessage_downgradeAsPath",&obj0)) SWIG_fail;
24996  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
24997  if (!SWIG_IsOK(res1)) {
24998  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_downgradeAsPath" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
24999  }
25000  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25001  result = (bool)(arg1)->downgradeAsPath();
25002  resultobj = SWIG_From_bool(static_cast< bool >(result));
25003  return resultobj;
25004 fail:
25005  return NULL;
25006 }
25007 
25008 
25009 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_restoreAggregator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25010  PyObject *resultobj = 0;
25012  void *argp1 = 0 ;
25013  int res1 = 0 ;
25014  PyObject * obj0 = 0 ;
25015  bool result;
25016 
25017  if (!PyArg_ParseTuple(args,(char *)"O:BgpUpdateMessage_restoreAggregator",&obj0)) SWIG_fail;
25018  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
25019  if (!SWIG_IsOK(res1)) {
25020  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_restoreAggregator" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
25021  }
25022  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25023  result = (bool)(arg1)->restoreAggregator();
25024  resultobj = SWIG_From_bool(static_cast< bool >(result));
25025  return resultobj;
25026 fail:
25027  return NULL;
25028 }
25029 
25030 
25031 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_downgradeAggregator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25032  PyObject *resultobj = 0;
25034  void *argp1 = 0 ;
25035  int res1 = 0 ;
25036  PyObject * obj0 = 0 ;
25037  bool result;
25038 
25039  if (!PyArg_ParseTuple(args,(char *)"O:BgpUpdateMessage_downgradeAggregator",&obj0)) SWIG_fail;
25040  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
25041  if (!SWIG_IsOK(res1)) {
25042  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_downgradeAggregator" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
25043  }
25044  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25045  result = (bool)(arg1)->downgradeAggregator();
25046  resultobj = SWIG_From_bool(static_cast< bool >(result));
25047  return resultobj;
25048 fail:
25049  return NULL;
25050 }
25051 
25052 
25053 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_setWithdrawn4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25054  PyObject *resultobj = 0;
25056  std::vector< libbgp::Prefix4 > *arg2 = 0 ;
25057  void *argp1 = 0 ;
25058  int res1 = 0 ;
25059  void *argp2 = 0 ;
25060  int res2 = 0 ;
25061  PyObject * obj0 = 0 ;
25062  PyObject * obj1 = 0 ;
25063  bool result;
25064 
25065  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_setWithdrawn4",&obj0,&obj1)) SWIG_fail;
25066  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
25067  if (!SWIG_IsOK(res1)) {
25068  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_setWithdrawn4" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
25069  }
25070  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25071  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0 | 0);
25072  if (!SWIG_IsOK(res2)) {
25073  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpUpdateMessage_setWithdrawn4" "', argument " "2"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
25074  }
25075  if (!argp2) {
25076  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpUpdateMessage_setWithdrawn4" "', argument " "2"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
25077  }
25078  arg2 = reinterpret_cast< std::vector< libbgp::Prefix4 > * >(argp2);
25079  result = (bool)(arg1)->setWithdrawn4((std::vector< libbgp::Prefix4 > const &)*arg2);
25080  resultobj = SWIG_From_bool(static_cast< bool >(result));
25081  return resultobj;
25082 fail:
25083  return NULL;
25084 }
25085 
25086 
25087 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_addWithdrawn4__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25088  PyObject *resultobj = 0;
25090  uint32_t arg2 ;
25091  uint8_t arg3 ;
25092  void *argp1 = 0 ;
25093  int res1 = 0 ;
25094  unsigned int val2 ;
25095  int ecode2 = 0 ;
25096  unsigned char val3 ;
25097  int ecode3 = 0 ;
25098  PyObject * obj0 = 0 ;
25099  PyObject * obj1 = 0 ;
25100  PyObject * obj2 = 0 ;
25101  bool result;
25102 
25103  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpUpdateMessage_addWithdrawn4",&obj0,&obj1,&obj2)) SWIG_fail;
25104  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
25105  if (!SWIG_IsOK(res1)) {
25106  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_addWithdrawn4" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
25107  }
25108  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25109  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
25110  if (!SWIG_IsOK(ecode2)) {
25111  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpUpdateMessage_addWithdrawn4" "', argument " "2"" of type '" "uint32_t""'");
25112  }
25113  arg2 = static_cast< uint32_t >(val2);
25114  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
25115  if (!SWIG_IsOK(ecode3)) {
25116  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpUpdateMessage_addWithdrawn4" "', argument " "3"" of type '" "uint8_t""'");
25117  }
25118  arg3 = static_cast< uint8_t >(val3);
25119  result = (bool)(arg1)->addWithdrawn4(arg2,arg3);
25120  resultobj = SWIG_From_bool(static_cast< bool >(result));
25121  return resultobj;
25122 fail:
25123  return NULL;
25124 }
25125 
25126 
25127 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_addWithdrawn4__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25128  PyObject *resultobj = 0;
25130  libbgp::Prefix4 *arg2 = 0 ;
25131  void *argp1 = 0 ;
25132  int res1 = 0 ;
25133  void *argp2 = 0 ;
25134  int res2 = 0 ;
25135  PyObject * obj0 = 0 ;
25136  PyObject * obj1 = 0 ;
25137  bool result;
25138 
25139  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_addWithdrawn4",&obj0,&obj1)) SWIG_fail;
25140  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
25141  if (!SWIG_IsOK(res1)) {
25142  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_addWithdrawn4" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
25143  }
25144  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25145  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix4, 0 | 0);
25146  if (!SWIG_IsOK(res2)) {
25147  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpUpdateMessage_addWithdrawn4" "', argument " "2"" of type '" "libbgp::Prefix4 const &""'");
25148  }
25149  if (!argp2) {
25150  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpUpdateMessage_addWithdrawn4" "', argument " "2"" of type '" "libbgp::Prefix4 const &""'");
25151  }
25152  arg2 = reinterpret_cast< libbgp::Prefix4 * >(argp2);
25153  result = (bool)(arg1)->addWithdrawn4((libbgp::Prefix4 const &)*arg2);
25154  resultobj = SWIG_From_bool(static_cast< bool >(result));
25155  return resultobj;
25156 fail:
25157  return NULL;
25158 }
25159 
25160 
25161 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_addWithdrawn4(PyObject *self, PyObject *args) {
25162  Py_ssize_t argc;
25163  PyObject *argv[4] = {
25164  0
25165  };
25166  Py_ssize_t ii;
25167 
25168  if (!PyTuple_Check(args)) SWIG_fail;
25169  argc = args ? PyObject_Length(args) : 0;
25170  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
25171  argv[ii] = PyTuple_GET_ITEM(args,ii);
25172  }
25173  if (argc == 2) {
25174  int _v;
25175  void *vptr = 0;
25176  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpUpdateMessage, 0);
25177  _v = SWIG_CheckState(res);
25178  if (_v) {
25179  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_libbgp__Prefix4, 0);
25180  _v = SWIG_CheckState(res);
25181  if (_v) {
25182  return _wrap_BgpUpdateMessage_addWithdrawn4__SWIG_1(self, args);
25183  }
25184  }
25185  }
25186  if (argc == 3) {
25187  int _v;
25188  void *vptr = 0;
25189  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpUpdateMessage, 0);
25190  _v = SWIG_CheckState(res);
25191  if (_v) {
25192  {
25193  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
25194  _v = SWIG_CheckState(res);
25195  }
25196  if (_v) {
25197  {
25198  int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
25199  _v = SWIG_CheckState(res);
25200  }
25201  if (_v) {
25202  return _wrap_BgpUpdateMessage_addWithdrawn4__SWIG_0(self, args);
25203  }
25204  }
25205  }
25206  }
25207 
25208 fail:
25209  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BgpUpdateMessage_addWithdrawn4'.\n"
25210  " Possible C/C++ prototypes are:\n"
25211  " libbgp::BgpUpdateMessage::addWithdrawn4(uint32_t,uint8_t)\n"
25212  " libbgp::BgpUpdateMessage::addWithdrawn4(libbgp::Prefix4 const &)\n");
25213  return 0;
25214 }
25215 
25216 
25217 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_setNlri4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25218  PyObject *resultobj = 0;
25220  std::vector< libbgp::Prefix4 > *arg2 = 0 ;
25221  void *argp1 = 0 ;
25222  int res1 = 0 ;
25223  void *argp2 = 0 ;
25224  int res2 = 0 ;
25225  PyObject * obj0 = 0 ;
25226  PyObject * obj1 = 0 ;
25227  bool result;
25228 
25229  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_setNlri4",&obj0,&obj1)) SWIG_fail;
25230  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
25231  if (!SWIG_IsOK(res1)) {
25232  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_setNlri4" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
25233  }
25234  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25235  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_libbgp__Prefix4_t, 0 | 0);
25236  if (!SWIG_IsOK(res2)) {
25237  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpUpdateMessage_setNlri4" "', argument " "2"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
25238  }
25239  if (!argp2) {
25240  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpUpdateMessage_setNlri4" "', argument " "2"" of type '" "std::vector< libbgp::Prefix4 > const &""'");
25241  }
25242  arg2 = reinterpret_cast< std::vector< libbgp::Prefix4 > * >(argp2);
25243  result = (bool)(arg1)->setNlri4((std::vector< libbgp::Prefix4 > const &)*arg2);
25244  resultobj = SWIG_From_bool(static_cast< bool >(result));
25245  return resultobj;
25246 fail:
25247  return NULL;
25248 }
25249 
25250 
25251 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_addNlri4__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25252  PyObject *resultobj = 0;
25254  uint32_t arg2 ;
25255  uint8_t arg3 ;
25256  void *argp1 = 0 ;
25257  int res1 = 0 ;
25258  unsigned int val2 ;
25259  int ecode2 = 0 ;
25260  unsigned char val3 ;
25261  int ecode3 = 0 ;
25262  PyObject * obj0 = 0 ;
25263  PyObject * obj1 = 0 ;
25264  PyObject * obj2 = 0 ;
25265  bool result;
25266 
25267  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpUpdateMessage_addNlri4",&obj0,&obj1,&obj2)) SWIG_fail;
25268  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
25269  if (!SWIG_IsOK(res1)) {
25270  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_addNlri4" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
25271  }
25272  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25273  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
25274  if (!SWIG_IsOK(ecode2)) {
25275  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpUpdateMessage_addNlri4" "', argument " "2"" of type '" "uint32_t""'");
25276  }
25277  arg2 = static_cast< uint32_t >(val2);
25278  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
25279  if (!SWIG_IsOK(ecode3)) {
25280  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpUpdateMessage_addNlri4" "', argument " "3"" of type '" "uint8_t""'");
25281  }
25282  arg3 = static_cast< uint8_t >(val3);
25283  result = (bool)(arg1)->addNlri4(arg2,arg3);
25284  resultobj = SWIG_From_bool(static_cast< bool >(result));
25285  return resultobj;
25286 fail:
25287  return NULL;
25288 }
25289 
25290 
25291 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_addNlri4__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25292  PyObject *resultobj = 0;
25294  libbgp::Prefix4 *arg2 = 0 ;
25295  void *argp1 = 0 ;
25296  int res1 = 0 ;
25297  void *argp2 = 0 ;
25298  int res2 = 0 ;
25299  PyObject * obj0 = 0 ;
25300  PyObject * obj1 = 0 ;
25301  bool result;
25302 
25303  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_addNlri4",&obj0,&obj1)) SWIG_fail;
25304  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
25305  if (!SWIG_IsOK(res1)) {
25306  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_addNlri4" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
25307  }
25308  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25309  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_libbgp__Prefix4, 0 | 0);
25310  if (!SWIG_IsOK(res2)) {
25311  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpUpdateMessage_addNlri4" "', argument " "2"" of type '" "libbgp::Prefix4 const &""'");
25312  }
25313  if (!argp2) {
25314  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpUpdateMessage_addNlri4" "', argument " "2"" of type '" "libbgp::Prefix4 const &""'");
25315  }
25316  arg2 = reinterpret_cast< libbgp::Prefix4 * >(argp2);
25317  result = (bool)(arg1)->addNlri4((libbgp::Prefix4 const &)*arg2);
25318  resultobj = SWIG_From_bool(static_cast< bool >(result));
25319  return resultobj;
25320 fail:
25321  return NULL;
25322 }
25323 
25324 
25325 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_addNlri4(PyObject *self, PyObject *args) {
25326  Py_ssize_t argc;
25327  PyObject *argv[4] = {
25328  0
25329  };
25330  Py_ssize_t ii;
25331 
25332  if (!PyTuple_Check(args)) SWIG_fail;
25333  argc = args ? PyObject_Length(args) : 0;
25334  for (ii = 0; (ii < 3) && (ii < argc); ii++) {
25335  argv[ii] = PyTuple_GET_ITEM(args,ii);
25336  }
25337  if (argc == 2) {
25338  int _v;
25339  void *vptr = 0;
25340  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpUpdateMessage, 0);
25341  _v = SWIG_CheckState(res);
25342  if (_v) {
25343  int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_libbgp__Prefix4, 0);
25344  _v = SWIG_CheckState(res);
25345  if (_v) {
25346  return _wrap_BgpUpdateMessage_addNlri4__SWIG_1(self, args);
25347  }
25348  }
25349  }
25350  if (argc == 3) {
25351  int _v;
25352  void *vptr = 0;
25353  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_libbgp__BgpUpdateMessage, 0);
25354  _v = SWIG_CheckState(res);
25355  if (_v) {
25356  {
25357  int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
25358  _v = SWIG_CheckState(res);
25359  }
25360  if (_v) {
25361  {
25362  int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
25363  _v = SWIG_CheckState(res);
25364  }
25365  if (_v) {
25366  return _wrap_BgpUpdateMessage_addNlri4__SWIG_0(self, args);
25367  }
25368  }
25369  }
25370  }
25371 
25372 fail:
25373  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'BgpUpdateMessage_addNlri4'.\n"
25374  " Possible C/C++ prototypes are:\n"
25375  " libbgp::BgpUpdateMessage::addNlri4(uint32_t,uint8_t)\n"
25376  " libbgp::BgpUpdateMessage::addNlri4(libbgp::Prefix4 const &)\n");
25377  return 0;
25378 }
25379 
25380 
25381 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_setWithdrawn6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25382  PyObject *resultobj = 0;
25384  std::vector< libbgp::Prefix6 > *arg2 = 0 ;
25385  void *argp1 = 0 ;
25386  int res1 = 0 ;
25387  void *argp2 = 0 ;
25388  int res2 = 0 ;
25389  PyObject * obj0 = 0 ;
25390  PyObject * obj1 = 0 ;
25391  bool result;
25392 
25393  if (!PyArg_ParseTuple(args,(char *)"OO:BgpUpdateMessage_setWithdrawn6",&obj0,&obj1)) SWIG_fail;
25394  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
25395  if (!SWIG_IsOK(res1)) {
25396  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_setWithdrawn6" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
25397  }
25398  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25399  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0 | 0);
25400  if (!SWIG_IsOK(res2)) {
25401  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpUpdateMessage_setWithdrawn6" "', argument " "2"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
25402  }
25403  if (!argp2) {
25404  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpUpdateMessage_setWithdrawn6" "', argument " "2"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
25405  }
25406  arg2 = reinterpret_cast< std::vector< libbgp::Prefix6 > * >(argp2);
25407  result = (bool)(arg1)->setWithdrawn6((std::vector< libbgp::Prefix6 > const &)*arg2);
25408  resultobj = SWIG_From_bool(static_cast< bool >(result));
25409  return resultobj;
25410 fail:
25411  return NULL;
25412 }
25413 
25414 
25415 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_setNlri6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25416  PyObject *resultobj = 0;
25418  std::vector< libbgp::Prefix6 > *arg2 = 0 ;
25419  uint8_t *arg3 ;
25420  uint8_t *arg4 ;
25421  void *argp1 = 0 ;
25422  int res1 = 0 ;
25423  void *argp2 = 0 ;
25424  int res2 = 0 ;
25425  void *argp3 = 0 ;
25426  int res3 = 0 ;
25427  void *argp4 = 0 ;
25428  int res4 = 0 ;
25429  PyObject * obj0 = 0 ;
25430  PyObject * obj1 = 0 ;
25431  PyObject * obj2 = 0 ;
25432  PyObject * obj3 = 0 ;
25433  bool result;
25434 
25435  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpUpdateMessage_setNlri6",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25436  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
25437  if (!SWIG_IsOK(res1)) {
25438  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_setNlri6" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
25439  }
25440  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25441  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_libbgp__Prefix6_t, 0 | 0);
25442  if (!SWIG_IsOK(res2)) {
25443  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpUpdateMessage_setNlri6" "', argument " "2"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
25444  }
25445  if (!argp2) {
25446  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BgpUpdateMessage_setNlri6" "', argument " "2"" of type '" "std::vector< libbgp::Prefix6 > const &""'");
25447  }
25448  arg2 = reinterpret_cast< std::vector< libbgp::Prefix6 > * >(argp2);
25449  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 | 0 );
25450  if (!SWIG_IsOK(res3)) {
25451  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpUpdateMessage_setNlri6" "', argument " "3"" of type '" "uint8_t const [16]""'");
25452  }
25453  arg3 = reinterpret_cast< uint8_t * >(argp3);
25454  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_char, 0 | 0 );
25455  if (!SWIG_IsOK(res4)) {
25456  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpUpdateMessage_setNlri6" "', argument " "4"" of type '" "uint8_t const [16]""'");
25457  }
25458  arg4 = reinterpret_cast< uint8_t * >(argp4);
25459  result = (bool)(arg1)->setNlri6((std::vector< libbgp::Prefix6 > const &)*arg2,(uint8_t const (*))arg3,(uint8_t const (*))arg4);
25460  resultobj = SWIG_From_bool(static_cast< bool >(result));
25461  return resultobj;
25462 fail:
25463  return NULL;
25464 }
25465 
25466 
25467 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_doPrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25468  PyObject *resultobj = 0;
25470  size_t arg2 ;
25471  uint8_t **arg3 = (uint8_t **) 0 ;
25472  size_t *arg4 = (size_t *) 0 ;
25473  void *argp1 = 0 ;
25474  int res1 = 0 ;
25475  size_t val2 ;
25476  int ecode2 = 0 ;
25477  void *argp3 = 0 ;
25478  int res3 = 0 ;
25479  void *argp4 = 0 ;
25480  int res4 = 0 ;
25481  PyObject * obj0 = 0 ;
25482  PyObject * obj1 = 0 ;
25483  PyObject * obj2 = 0 ;
25484  PyObject * obj3 = 0 ;
25485  ssize_t result;
25486 
25487  if (!PyArg_ParseTuple(args,(char *)"OOOO:BgpUpdateMessage_doPrint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25488  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
25489  if (!SWIG_IsOK(res1)) {
25490  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_doPrint" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage const *""'");
25491  }
25492  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25493  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
25494  if (!SWIG_IsOK(ecode2)) {
25495  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BgpUpdateMessage_doPrint" "', argument " "2"" of type '" "size_t""'");
25496  }
25497  arg2 = static_cast< size_t >(val2);
25498  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_unsigned_char, 0 | 0 );
25499  if (!SWIG_IsOK(res3)) {
25500  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BgpUpdateMessage_doPrint" "', argument " "3"" of type '" "uint8_t **""'");
25501  }
25502  arg3 = reinterpret_cast< uint8_t ** >(argp3);
25503  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_size_t, 0 | 0 );
25504  if (!SWIG_IsOK(res4)) {
25505  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BgpUpdateMessage_doPrint" "', argument " "4"" of type '" "size_t *""'");
25506  }
25507  arg4 = reinterpret_cast< size_t * >(argp4);
25508  result = ((libbgp::BgpUpdateMessage const *)arg1)->doPrint(arg2,arg3,arg4);
25509  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
25510  return resultobj;
25511 fail:
25512  return NULL;
25513 }
25514 
25515 
25516 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_parse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25517  PyObject *resultobj = 0;
25519  uint8_t *arg2 = (uint8_t *) 0 ;
25520  size_t arg3 ;
25521  void *argp1 = 0 ;
25522  int res1 = 0 ;
25523  void *argp2 = 0 ;
25524  int res2 = 0 ;
25525  size_t val3 ;
25526  int ecode3 = 0 ;
25527  PyObject * obj0 = 0 ;
25528  PyObject * obj1 = 0 ;
25529  PyObject * obj2 = 0 ;
25530  ssize_t result;
25531 
25532  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpUpdateMessage_parse",&obj0,&obj1,&obj2)) SWIG_fail;
25533  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
25534  if (!SWIG_IsOK(res1)) {
25535  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_parse" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
25536  }
25537  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25538  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
25539  if (!SWIG_IsOK(res2)) {
25540  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpUpdateMessage_parse" "', argument " "2"" of type '" "uint8_t const *""'");
25541  }
25542  arg2 = reinterpret_cast< uint8_t * >(argp2);
25543  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
25544  if (!SWIG_IsOK(ecode3)) {
25545  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpUpdateMessage_parse" "', argument " "3"" of type '" "size_t""'");
25546  }
25547  arg3 = static_cast< size_t >(val3);
25548  result = (arg1)->parse((uint8_t const *)arg2,arg3);
25549  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
25550  return resultobj;
25551 fail:
25552  return NULL;
25553 }
25554 
25555 
25556 SWIGINTERN PyObject *_wrap_BgpUpdateMessage_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25557  PyObject *resultobj = 0;
25559  uint8_t *arg2 = (uint8_t *) 0 ;
25560  size_t arg3 ;
25561  void *argp1 = 0 ;
25562  int res1 = 0 ;
25563  void *argp2 = 0 ;
25564  int res2 = 0 ;
25565  size_t val3 ;
25566  int ecode3 = 0 ;
25567  PyObject * obj0 = 0 ;
25568  PyObject * obj1 = 0 ;
25569  PyObject * obj2 = 0 ;
25570  ssize_t result;
25571 
25572  if (!PyArg_ParseTuple(args,(char *)"OOO:BgpUpdateMessage_write",&obj0,&obj1,&obj2)) SWIG_fail;
25573  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, 0 | 0 );
25574  if (!SWIG_IsOK(res1)) {
25575  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BgpUpdateMessage_write" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage const *""'");
25576  }
25577  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25578  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
25579  if (!SWIG_IsOK(res2)) {
25580  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BgpUpdateMessage_write" "', argument " "2"" of type '" "uint8_t *""'");
25581  }
25582  arg2 = reinterpret_cast< uint8_t * >(argp2);
25583  ecode3 = SWIG_AsVal_size_t(obj2, &val3);
25584  if (!SWIG_IsOK(ecode3)) {
25585  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BgpUpdateMessage_write" "', argument " "3"" of type '" "size_t""'");
25586  }
25587  arg3 = static_cast< size_t >(val3);
25588  result = ((libbgp::BgpUpdateMessage const *)arg1)->write(arg2,arg3);
25589  resultobj = SWIG_NewPointerObj((new ssize_t(static_cast< const ssize_t& >(result))), SWIGTYPE_p_ssize_t, SWIG_POINTER_OWN | 0 );
25590  return resultobj;
25591 fail:
25592  return NULL;
25593 }
25594 
25595 
25596 SWIGINTERN PyObject *_wrap_delete_BgpUpdateMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25597  PyObject *resultobj = 0;
25599  void *argp1 = 0 ;
25600  int res1 = 0 ;
25601  PyObject * obj0 = 0 ;
25602 
25603  if (!PyArg_ParseTuple(args,(char *)"O:delete_BgpUpdateMessage",&obj0)) SWIG_fail;
25604  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__BgpUpdateMessage, SWIG_POINTER_DISOWN | 0 );
25605  if (!SWIG_IsOK(res1)) {
25606  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BgpUpdateMessage" "', argument " "1"" of type '" "libbgp::BgpUpdateMessage *""'");
25607  }
25608  arg1 = reinterpret_cast< libbgp::BgpUpdateMessage * >(argp1);
25609  delete arg1;
25610  resultobj = SWIG_Py_Void();
25611  return resultobj;
25612 fail:
25613  return NULL;
25614 }
25615 
25616 
25617 SWIGINTERN PyObject *BgpUpdateMessage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25618  PyObject *obj;
25619  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
25620  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__BgpUpdateMessage, SWIG_NewClientData(obj));
25621  return SWIG_Py_Void();
25622 }
25623 
25624 SWIGINTERN PyObject *_wrap_Clock_getTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25625  PyObject *resultobj = 0;
25626  libbgp::Clock *arg1 = (libbgp::Clock *) 0 ;
25627  void *argp1 = 0 ;
25628  int res1 = 0 ;
25629  PyObject * obj0 = 0 ;
25630  uint64_t result;
25631 
25632  if (!PyArg_ParseTuple(args,(char *)"O:Clock_getTime",&obj0)) SWIG_fail;
25633  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Clock, 0 | 0 );
25634  if (!SWIG_IsOK(res1)) {
25635  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clock_getTime" "', argument " "1"" of type '" "libbgp::Clock const *""'");
25636  }
25637  arg1 = reinterpret_cast< libbgp::Clock * >(argp1);
25638  result = (uint64_t)((libbgp::Clock const *)arg1)->getTime();
25639  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
25640  return resultobj;
25641 fail:
25642  return NULL;
25643 }
25644 
25645 
25646 SWIGINTERN PyObject *_wrap_delete_Clock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25647  PyObject *resultobj = 0;
25648  libbgp::Clock *arg1 = (libbgp::Clock *) 0 ;
25649  void *argp1 = 0 ;
25650  int res1 = 0 ;
25651  PyObject * obj0 = 0 ;
25652 
25653  if (!PyArg_ParseTuple(args,(char *)"O:delete_Clock",&obj0)) SWIG_fail;
25654  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__Clock, SWIG_POINTER_DISOWN | 0 );
25655  if (!SWIG_IsOK(res1)) {
25656  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clock" "', argument " "1"" of type '" "libbgp::Clock *""'");
25657  }
25658  arg1 = reinterpret_cast< libbgp::Clock * >(argp1);
25659  delete arg1;
25660  resultobj = SWIG_Py_Void();
25661  return resultobj;
25662 fail:
25663  return NULL;
25664 }
25665 
25666 
25667 SWIGINTERN PyObject *Clock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25668  PyObject *obj;
25669  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
25670  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__Clock, SWIG_NewClientData(obj));
25671  return SWIG_Py_Void();
25672 }
25673 
25674 SWIGINTERN PyObject *_wrap_RealtimeClock_getTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25675  PyObject *resultobj = 0;
25677  void *argp1 = 0 ;
25678  int res1 = 0 ;
25679  PyObject * obj0 = 0 ;
25680  uint64_t result;
25681 
25682  if (!PyArg_ParseTuple(args,(char *)"O:RealtimeClock_getTime",&obj0)) SWIG_fail;
25683  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__RealtimeClock, 0 | 0 );
25684  if (!SWIG_IsOK(res1)) {
25685  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealtimeClock_getTime" "', argument " "1"" of type '" "libbgp::RealtimeClock const *""'");
25686  }
25687  arg1 = reinterpret_cast< libbgp::RealtimeClock * >(argp1);
25688  result = (uint64_t)((libbgp::RealtimeClock const *)arg1)->getTime();
25689  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
25690  return resultobj;
25691 fail:
25692  return NULL;
25693 }
25694 
25695 
25696 SWIGINTERN PyObject *_wrap_new_RealtimeClock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25697  PyObject *resultobj = 0;
25698  libbgp::RealtimeClock *result = 0 ;
25699 
25700  if (!PyArg_ParseTuple(args,(char *)":new_RealtimeClock")) SWIG_fail;
25701  result = (libbgp::RealtimeClock *)new libbgp::RealtimeClock();
25702  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_libbgp__RealtimeClock, SWIG_POINTER_NEW | 0 );
25703  return resultobj;
25704 fail:
25705  return NULL;
25706 }
25707 
25708 
25709 SWIGINTERN PyObject *_wrap_delete_RealtimeClock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25710  PyObject *resultobj = 0;
25712  void *argp1 = 0 ;
25713  int res1 = 0 ;
25714  PyObject * obj0 = 0 ;
25715 
25716  if (!PyArg_ParseTuple(args,(char *)"O:delete_RealtimeClock",&obj0)) SWIG_fail;
25717  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_libbgp__RealtimeClock, SWIG_POINTER_DISOWN | 0 );
25718  if (!SWIG_IsOK(res1)) {
25719  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealtimeClock" "', argument " "1"" of type '" "libbgp::RealtimeClock *""'");
25720  }
25721  arg1 = reinterpret_cast< libbgp::RealtimeClock * >(argp1);
25722  delete arg1;
25723  resultobj = SWIG_Py_Void();
25724  return resultobj;
25725 fail:
25726  return NULL;
25727 }
25728 
25729 
25730 SWIGINTERN PyObject *RealtimeClock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25731  PyObject *obj;
25732  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
25733  SWIG_TypeNewClientData(SWIGTYPE_p_libbgp__RealtimeClock, SWIG_NewClientData(obj));
25734  return SWIG_Py_Void();
25735 }
25736 
25737 static PyMethodDef SwigMethods[] = {
25738  { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
25739  { (char *)"delete_Serializable", _wrap_delete_Serializable, METH_VARARGS, NULL},
25740  { (char *)"Serializable__print", _wrap_Serializable__print, METH_VARARGS, NULL},
25741  { (char *)"Serializable_parse", _wrap_Serializable_parse, METH_VARARGS, NULL},
25742  { (char *)"Serializable_write", _wrap_Serializable_write, METH_VARARGS, NULL},
25743  { (char *)"Serializable_length", _wrap_Serializable_length, METH_VARARGS, NULL},
25744  { (char *)"Serializable_hasError", _wrap_Serializable_hasError, METH_VARARGS, NULL},
25745  { (char *)"Serializable_getErrorCode", _wrap_Serializable_getErrorCode, METH_VARARGS, NULL},
25746  { (char *)"Serializable_getErrorSubCode", _wrap_Serializable_getErrorSubCode, METH_VARARGS, NULL},
25747  { (char *)"Serializable_getError", _wrap_Serializable_getError, METH_VARARGS, NULL},
25748  { (char *)"Serializable_getErrorLength", _wrap_Serializable_getErrorLength, METH_VARARGS, NULL},
25749  { (char *)"Serializable_setLogger", _wrap_Serializable_setLogger, METH_VARARGS, NULL},
25750  { (char *)"Serializable_swigregister", Serializable_swigregister, METH_VARARGS, NULL},
25751  { (char *)"RouteEvent_type_set", _wrap_RouteEvent_type_set, METH_VARARGS, NULL},
25752  { (char *)"RouteEvent_type_get", _wrap_RouteEvent_type_get, METH_VARARGS, NULL},
25753  { (char *)"delete_RouteEvent", _wrap_delete_RouteEvent, METH_VARARGS, NULL},
25754  { (char *)"new_RouteEvent", _wrap_new_RouteEvent, METH_VARARGS, NULL},
25755  { (char *)"RouteEvent_swigregister", RouteEvent_swigregister, METH_VARARGS, NULL},
25756  { (char *)"new_Route4AddEvent", _wrap_new_Route4AddEvent, METH_VARARGS, NULL},
25757  { (char *)"Route4AddEvent_attribs_set", _wrap_Route4AddEvent_attribs_set, METH_VARARGS, NULL},
25758  { (char *)"Route4AddEvent_attribs_get", _wrap_Route4AddEvent_attribs_get, METH_VARARGS, NULL},
25759  { (char *)"Route4AddEvent_routes_set", _wrap_Route4AddEvent_routes_set, METH_VARARGS, NULL},
25760  { (char *)"Route4AddEvent_routes_get", _wrap_Route4AddEvent_routes_get, METH_VARARGS, NULL},
25761  { (char *)"delete_Route4AddEvent", _wrap_delete_Route4AddEvent, METH_VARARGS, NULL},
25762  { (char *)"Route4AddEvent_swigregister", Route4AddEvent_swigregister, METH_VARARGS, NULL},
25763  { (char *)"new_Route4WithdrawEvent", _wrap_new_Route4WithdrawEvent, METH_VARARGS, NULL},
25764  { (char *)"Route4WithdrawEvent_routes_set", _wrap_Route4WithdrawEvent_routes_set, METH_VARARGS, NULL},
25765  { (char *)"Route4WithdrawEvent_routes_get", _wrap_Route4WithdrawEvent_routes_get, METH_VARARGS, NULL},
25766  { (char *)"delete_Route4WithdrawEvent", _wrap_delete_Route4WithdrawEvent, METH_VARARGS, NULL},
25767  { (char *)"Route4WithdrawEvent_swigregister", Route4WithdrawEvent_swigregister, METH_VARARGS, NULL},
25768  { (char *)"new_Route6AddEvent", _wrap_new_Route6AddEvent, METH_VARARGS, NULL},
25769  { (char *)"Route6AddEvent_attribs_set", _wrap_Route6AddEvent_attribs_set, METH_VARARGS, NULL},
25770  { (char *)"Route6AddEvent_attribs_get", _wrap_Route6AddEvent_attribs_get, METH_VARARGS, NULL},
25771  { (char *)"Route6AddEvent_routes_set", _wrap_Route6AddEvent_routes_set, METH_VARARGS, NULL},
25772  { (char *)"Route6AddEvent_routes_get", _wrap_Route6AddEvent_routes_get, METH_VARARGS, NULL},
25773  { (char *)"delete_Route6AddEvent", _wrap_delete_Route6AddEvent, METH_VARARGS, NULL},
25774  { (char *)"Route6AddEvent_swigregister", Route6AddEvent_swigregister, METH_VARARGS, NULL},
25775  { (char *)"new_Route6WithdrawEvent", _wrap_new_Route6WithdrawEvent, METH_VARARGS, NULL},
25776  { (char *)"Route6WithdrawEvent_routes_set", _wrap_Route6WithdrawEvent_routes_set, METH_VARARGS, NULL},
25777  { (char *)"Route6WithdrawEvent_routes_get", _wrap_Route6WithdrawEvent_routes_get, METH_VARARGS, NULL},
25778  { (char *)"delete_Route6WithdrawEvent", _wrap_delete_Route6WithdrawEvent, METH_VARARGS, NULL},
25779  { (char *)"Route6WithdrawEvent_swigregister", Route6WithdrawEvent_swigregister, METH_VARARGS, NULL},
25780  { (char *)"new_RouteCollisionEvent", _wrap_new_RouteCollisionEvent, METH_VARARGS, NULL},
25781  { (char *)"RouteCollisionEvent_peer_bgp_id_set", _wrap_RouteCollisionEvent_peer_bgp_id_set, METH_VARARGS, NULL},
25782  { (char *)"RouteCollisionEvent_peer_bgp_id_get", _wrap_RouteCollisionEvent_peer_bgp_id_get, METH_VARARGS, NULL},
25783  { (char *)"delete_RouteCollisionEvent", _wrap_delete_RouteCollisionEvent, METH_VARARGS, NULL},
25784  { (char *)"RouteCollisionEvent_swigregister", RouteCollisionEvent_swigregister, METH_VARARGS, NULL},
25785  { (char *)"delete_RouteEventReceiver", _wrap_delete_RouteEventReceiver, METH_VARARGS, NULL},
25786  { (char *)"RouteEventReceiver_swigregister", RouteEventReceiver_swigregister, METH_VARARGS, NULL},
25787  { (char *)"new_RouteEventBus", _wrap_new_RouteEventBus, METH_VARARGS, NULL},
25788  { (char *)"RouteEventBus_publish", _wrap_RouteEventBus_publish, METH_VARARGS, NULL},
25789  { (char *)"RouteEventBus_subscribe", _wrap_RouteEventBus_subscribe, METH_VARARGS, NULL},
25790  { (char *)"RouteEventBus_unsubscribe", _wrap_RouteEventBus_unsubscribe, METH_VARARGS, NULL},
25791  { (char *)"delete_RouteEventBus", _wrap_delete_RouteEventBus, METH_VARARGS, NULL},
25792  { (char *)"RouteEventBus_swigregister", RouteEventBus_swigregister, METH_VARARGS, NULL},
25793  { (char *)"cidr_to_mask", _wrap_cidr_to_mask, METH_VARARGS, NULL},
25794  { (char *)"Prefix_afi_set", _wrap_Prefix_afi_set, METH_VARARGS, NULL},
25795  { (char *)"Prefix_afi_get", _wrap_Prefix_afi_get, METH_VARARGS, NULL},
25796  { (char *)"Prefix_parse", _wrap_Prefix_parse, METH_VARARGS, NULL},
25797  { (char *)"Prefix_write", _wrap_Prefix_write, METH_VARARGS, NULL},
25798  { (char *)"Prefix_includes", _wrap_Prefix_includes, METH_VARARGS, NULL},
25799  { (char *)"Prefix___eq__", _wrap_Prefix___eq__, METH_VARARGS, NULL},
25800  { (char *)"Prefix___gt__", _wrap_Prefix___gt__, METH_VARARGS, NULL},
25801  { (char *)"Prefix___lt__", _wrap_Prefix___lt__, METH_VARARGS, NULL},
25802  { (char *)"Prefix___ge__", _wrap_Prefix___ge__, METH_VARARGS, NULL},
25803  { (char *)"Prefix___le__", _wrap_Prefix___le__, METH_VARARGS, NULL},
25804  { (char *)"Prefix___ne__", _wrap_Prefix___ne__, METH_VARARGS, NULL},
25805  { (char *)"delete_Prefix", _wrap_delete_Prefix, METH_VARARGS, NULL},
25806  { (char *)"Prefix_swigregister", Prefix_swigregister, METH_VARARGS, NULL},
25807  { (char *)"new_Prefix4", _wrap_new_Prefix4, METH_VARARGS, NULL},
25808  { (char *)"Prefix4_parse", _wrap_Prefix4_parse, METH_VARARGS, NULL},
25809  { (char *)"Prefix4_write", _wrap_Prefix4_write, METH_VARARGS, NULL},
25810  { (char *)"Prefix4_Includes", _wrap_Prefix4_Includes, METH_VARARGS, NULL},
25811  { (char *)"Prefix4_includes", _wrap_Prefix4_includes, METH_VARARGS, NULL},
25812  { (char *)"Prefix4___eq__", _wrap_Prefix4___eq__, METH_VARARGS, NULL},
25813  { (char *)"Prefix4___gt__", _wrap_Prefix4___gt__, METH_VARARGS, NULL},
25814  { (char *)"Prefix4___lt__", _wrap_Prefix4___lt__, METH_VARARGS, NULL},
25815  { (char *)"Prefix4___ge__", _wrap_Prefix4___ge__, METH_VARARGS, NULL},
25816  { (char *)"Prefix4___le__", _wrap_Prefix4___le__, METH_VARARGS, NULL},
25817  { (char *)"Prefix4___ne__", _wrap_Prefix4___ne__, METH_VARARGS, NULL},
25818  { (char *)"Prefix4_set", _wrap_Prefix4_set, METH_VARARGS, NULL},
25819  { (char *)"Prefix4_setPrefix", _wrap_Prefix4_setPrefix, METH_VARARGS, NULL},
25820  { (char *)"Prefix4_setLength", _wrap_Prefix4_setLength, METH_VARARGS, NULL},
25821  { (char *)"Prefix4_getPrefix", _wrap_Prefix4_getPrefix, METH_VARARGS, NULL},
25822  { (char *)"Prefix4_getLength", _wrap_Prefix4_getLength, METH_VARARGS, NULL},
25823  { (char *)"Prefix4_getMask", _wrap_Prefix4_getMask, METH_VARARGS, NULL},
25824  { (char *)"delete_Prefix4", _wrap_delete_Prefix4, METH_VARARGS, NULL},
25825  { (char *)"Prefix4_swigregister", Prefix4_swigregister, METH_VARARGS, NULL},
25826  { (char *)"cidr_to_mask6", _wrap_cidr_to_mask6, METH_VARARGS, NULL},
25827  { (char *)"mask_ipv6", _wrap_mask_ipv6, METH_VARARGS, NULL},
25828  { (char *)"v6addr_is_zero", _wrap_v6addr_is_zero, METH_VARARGS, NULL},
25829  { (char *)"new_Prefix6", _wrap_new_Prefix6, METH_VARARGS, NULL},
25830  { (char *)"Prefix6_parse", _wrap_Prefix6_parse, METH_VARARGS, NULL},
25831  { (char *)"Prefix6_write", _wrap_Prefix6_write, METH_VARARGS, NULL},
25832  { (char *)"Prefix6_Includes", _wrap_Prefix6_Includes, METH_VARARGS, NULL},
25833  { (char *)"Prefix6_includes", _wrap_Prefix6_includes, METH_VARARGS, NULL},
25834  { (char *)"Prefix6___eq__", _wrap_Prefix6___eq__, METH_VARARGS, NULL},
25835  { (char *)"Prefix6___gt__", _wrap_Prefix6___gt__, METH_VARARGS, NULL},
25836  { (char *)"Prefix6___lt__", _wrap_Prefix6___lt__, METH_VARARGS, NULL},
25837  { (char *)"Prefix6___ge__", _wrap_Prefix6___ge__, METH_VARARGS, NULL},
25838  { (char *)"Prefix6___le__", _wrap_Prefix6___le__, METH_VARARGS, NULL},
25839  { (char *)"Prefix6___ne__", _wrap_Prefix6___ne__, METH_VARARGS, NULL},
25840  { (char *)"Prefix6_set", _wrap_Prefix6_set, METH_VARARGS, NULL},
25841  { (char *)"Prefix6_setPrefix", _wrap_Prefix6_setPrefix, METH_VARARGS, NULL},
25842  { (char *)"Prefix6_setLength", _wrap_Prefix6_setLength, METH_VARARGS, NULL},
25843  { (char *)"Prefix6_getPrefix", _wrap_Prefix6_getPrefix, METH_VARARGS, NULL},
25844  { (char *)"Prefix6_getLength", _wrap_Prefix6_getLength, METH_VARARGS, NULL},
25845  { (char *)"Prefix6_getMask", _wrap_Prefix6_getMask, METH_VARARGS, NULL},
25846  { (char *)"delete_Prefix6", _wrap_delete_Prefix6, METH_VARARGS, NULL},
25847  { (char *)"Prefix6_swigregister", Prefix6_swigregister, METH_VARARGS, NULL},
25848  { (char *)"BgpCapability_code_set", _wrap_BgpCapability_code_set, METH_VARARGS, NULL},
25849  { (char *)"BgpCapability_code_get", _wrap_BgpCapability_code_get, METH_VARARGS, NULL},
25850  { (char *)"delete_BgpCapability", _wrap_delete_BgpCapability, METH_VARARGS, NULL},
25851  { (char *)"BgpCapability_parse", _wrap_BgpCapability_parse, METH_VARARGS, NULL},
25852  { (char *)"BgpCapability_write", _wrap_BgpCapability_write, METH_VARARGS, NULL},
25853  { (char *)"BgpCapability_swigregister", BgpCapability_swigregister, METH_VARARGS, NULL},
25854  { (char *)"new_BgpCapability4BytesAsn", _wrap_new_BgpCapability4BytesAsn, METH_VARARGS, NULL},
25855  { (char *)"BgpCapability4BytesAsn_doPrint", _wrap_BgpCapability4BytesAsn_doPrint, METH_VARARGS, NULL},
25856  { (char *)"BgpCapability4BytesAsn_parse", _wrap_BgpCapability4BytesAsn_parse, METH_VARARGS, NULL},
25857  { (char *)"BgpCapability4BytesAsn_write", _wrap_BgpCapability4BytesAsn_write, METH_VARARGS, NULL},
25858  { (char *)"BgpCapability4BytesAsn_my_asn_set", _wrap_BgpCapability4BytesAsn_my_asn_set, METH_VARARGS, NULL},
25859  { (char *)"BgpCapability4BytesAsn_my_asn_get", _wrap_BgpCapability4BytesAsn_my_asn_get, METH_VARARGS, NULL},
25860  { (char *)"delete_BgpCapability4BytesAsn", _wrap_delete_BgpCapability4BytesAsn, METH_VARARGS, NULL},
25861  { (char *)"BgpCapability4BytesAsn_swigregister", BgpCapability4BytesAsn_swigregister, METH_VARARGS, NULL},
25862  { (char *)"new_BgpCapabilityMpBgp", _wrap_new_BgpCapabilityMpBgp, METH_VARARGS, NULL},
25863  { (char *)"BgpCapabilityMpBgp_doPrint", _wrap_BgpCapabilityMpBgp_doPrint, METH_VARARGS, NULL},
25864  { (char *)"BgpCapabilityMpBgp_parse", _wrap_BgpCapabilityMpBgp_parse, METH_VARARGS, NULL},
25865  { (char *)"BgpCapabilityMpBgp_write", _wrap_BgpCapabilityMpBgp_write, METH_VARARGS, NULL},
25866  { (char *)"BgpCapabilityMpBgp_afi_set", _wrap_BgpCapabilityMpBgp_afi_set, METH_VARARGS, NULL},
25867  { (char *)"BgpCapabilityMpBgp_afi_get", _wrap_BgpCapabilityMpBgp_afi_get, METH_VARARGS, NULL},
25868  { (char *)"BgpCapabilityMpBgp_safi_set", _wrap_BgpCapabilityMpBgp_safi_set, METH_VARARGS, NULL},
25869  { (char *)"BgpCapabilityMpBgp_safi_get", _wrap_BgpCapabilityMpBgp_safi_get, METH_VARARGS, NULL},
25870  { (char *)"delete_BgpCapabilityMpBgp", _wrap_delete_BgpCapabilityMpBgp, METH_VARARGS, NULL},
25871  { (char *)"BgpCapabilityMpBgp_swigregister", BgpCapabilityMpBgp_swigregister, METH_VARARGS, NULL},
25872  { (char *)"new_BgpCapabilityUnknow", _wrap_new_BgpCapabilityUnknow, METH_VARARGS, NULL},
25873  { (char *)"delete_BgpCapabilityUnknow", _wrap_delete_BgpCapabilityUnknow, METH_VARARGS, NULL},
25874  { (char *)"BgpCapabilityUnknow_doPrint", _wrap_BgpCapabilityUnknow_doPrint, METH_VARARGS, NULL},
25875  { (char *)"BgpCapabilityUnknow_parse", _wrap_BgpCapabilityUnknow_parse, METH_VARARGS, NULL},
25876  { (char *)"BgpCapabilityUnknow_write", _wrap_BgpCapabilityUnknow_write, METH_VARARGS, NULL},
25877  { (char *)"BgpCapabilityUnknow_swigregister", BgpCapabilityUnknow_swigregister, METH_VARARGS, NULL},
25878  { (char *)"BgpFilterRule_filter_type_set", _wrap_BgpFilterRule_filter_type_set, METH_VARARGS, NULL},
25879  { (char *)"BgpFilterRule_filter_type_get", _wrap_BgpFilterRule_filter_type_get, METH_VARARGS, NULL},
25880  { (char *)"BgpFilterRule_match_type_set", _wrap_BgpFilterRule_match_type_set, METH_VARARGS, NULL},
25881  { (char *)"BgpFilterRule_match_type_get", _wrap_BgpFilterRule_match_type_get, METH_VARARGS, NULL},
25882  { (char *)"BgpFilterRule_op_set", _wrap_BgpFilterRule_op_set, METH_VARARGS, NULL},
25883  { (char *)"BgpFilterRule_op_get", _wrap_BgpFilterRule_op_get, METH_VARARGS, NULL},
25884  { (char *)"BgpFilterRule_apply", _wrap_BgpFilterRule_apply, METH_VARARGS, NULL},
25885  { (char *)"delete_BgpFilterRule", _wrap_delete_BgpFilterRule, METH_VARARGS, NULL},
25886  { (char *)"BgpFilterRule_swigregister", BgpFilterRule_swigregister, METH_VARARGS, NULL},
25887  { (char *)"new_Prefix4RouteFilterRule", _wrap_new_Prefix4RouteFilterRule, METH_VARARGS, NULL},
25888  { (char *)"Prefix4RouteFilterRule_prefix_set", _wrap_Prefix4RouteFilterRule_prefix_set, METH_VARARGS, NULL},
25889  { (char *)"Prefix4RouteFilterRule_prefix_get", _wrap_Prefix4RouteFilterRule_prefix_get, METH_VARARGS, NULL},
25890  { (char *)"Prefix4RouteFilterRule_apply", _wrap_Prefix4RouteFilterRule_apply, METH_VARARGS, NULL},
25891  { (char *)"delete_Prefix4RouteFilterRule", _wrap_delete_Prefix4RouteFilterRule, METH_VARARGS, NULL},
25892  { (char *)"Prefix4RouteFilterRule_swigregister", Prefix4RouteFilterRule_swigregister, METH_VARARGS, NULL},
25893  { (char *)"new_Prefix6RouteFilterRule", _wrap_new_Prefix6RouteFilterRule, METH_VARARGS, NULL},
25894  { (char *)"Prefix6RouteFilterRule_prefix_set", _wrap_Prefix6RouteFilterRule_prefix_set, METH_VARARGS, NULL},
25895  { (char *)"Prefix6RouteFilterRule_prefix_get", _wrap_Prefix6RouteFilterRule_prefix_get, METH_VARARGS, NULL},
25896  { (char *)"Prefix6RouteFilterRule_apply", _wrap_Prefix6RouteFilterRule_apply, METH_VARARGS, NULL},
25897  { (char *)"delete_Prefix6RouteFilterRule", _wrap_delete_Prefix6RouteFilterRule, METH_VARARGS, NULL},
25898  { (char *)"Prefix6RouteFilterRule_swigregister", Prefix6RouteFilterRule_swigregister, METH_VARARGS, NULL},
25899  { (char *)"new_BgpFilterRuleRoute4", _wrap_new_BgpFilterRuleRoute4, METH_VARARGS, NULL},
25900  { (char *)"delete_BgpFilterRuleRoute4", _wrap_delete_BgpFilterRuleRoute4, METH_VARARGS, NULL},
25901  { (char *)"BgpFilterRuleRoute4_swigregister", BgpFilterRuleRoute4_swigregister, METH_VARARGS, NULL},
25902  { (char *)"new_BgpFilterRuleRoute6", _wrap_new_BgpFilterRuleRoute6, METH_VARARGS, NULL},
25903  { (char *)"delete_BgpFilterRuleRoute6", _wrap_delete_BgpFilterRuleRoute6, METH_VARARGS, NULL},
25904  { (char *)"BgpFilterRuleRoute6_swigregister", BgpFilterRuleRoute6_swigregister, METH_VARARGS, NULL},
25905  { (char *)"new_BgpFilterRuleAsPath", _wrap_new_BgpFilterRuleAsPath, METH_VARARGS, NULL},
25906  { (char *)"BgpFilterRuleAsPath_asn_set", _wrap_BgpFilterRuleAsPath_asn_set, METH_VARARGS, NULL},
25907  { (char *)"BgpFilterRuleAsPath_asn_get", _wrap_BgpFilterRuleAsPath_asn_get, METH_VARARGS, NULL},
25908  { (char *)"BgpFilterRuleAsPath_apply", _wrap_BgpFilterRuleAsPath_apply, METH_VARARGS, NULL},
25909  { (char *)"delete_BgpFilterRuleAsPath", _wrap_delete_BgpFilterRuleAsPath, METH_VARARGS, NULL},
25910  { (char *)"BgpFilterRuleAsPath_swigregister", BgpFilterRuleAsPath_swigregister, METH_VARARGS, NULL},
25911  { (char *)"new_BgpFilterRuleCommunity", _wrap_new_BgpFilterRuleCommunity, METH_VARARGS, NULL},
25912  { (char *)"BgpFilterRuleCommunity_community_set", _wrap_BgpFilterRuleCommunity_community_set, METH_VARARGS, NULL},
25913  { (char *)"BgpFilterRuleCommunity_community_get", _wrap_BgpFilterRuleCommunity_community_get, METH_VARARGS, NULL},
25914  { (char *)"BgpFilterRuleCommunity_apply", _wrap_BgpFilterRuleCommunity_apply, METH_VARARGS, NULL},
25915  { (char *)"delete_BgpFilterRuleCommunity", _wrap_delete_BgpFilterRuleCommunity, METH_VARARGS, NULL},
25916  { (char *)"BgpFilterRuleCommunity_swigregister", BgpFilterRuleCommunity_swigregister, METH_VARARGS, NULL},
25917  { (char *)"new_BgpFilterRules", _wrap_new_BgpFilterRules, METH_VARARGS, NULL},
25918  { (char *)"BgpFilterRules_appendAsPathRule", _wrap_BgpFilterRules_appendAsPathRule, METH_VARARGS, NULL},
25919  { (char *)"BgpFilterRules_appendCommunityRule", _wrap_BgpFilterRules_appendCommunityRule, METH_VARARGS, NULL},
25920  { (char *)"BgpFilterRules_appendRoute4Rule", _wrap_BgpFilterRules_appendRoute4Rule, METH_VARARGS, NULL},
25921  { (char *)"BgpFilterRules_appendRoute6Rule", _wrap_BgpFilterRules_appendRoute6Rule, METH_VARARGS, NULL},
25922  { (char *)"BgpFilterRules_apply", _wrap_BgpFilterRules_apply, METH_VARARGS, NULL},
25923  { (char *)"delete_BgpFilterRules", _wrap_delete_BgpFilterRules, METH_VARARGS, NULL},
25924  { (char *)"BgpFilterRules_swigregister", BgpFilterRules_swigregister, METH_VARARGS, NULL},
25925  { (char *)"new_BgpConfig", _wrap_new_BgpConfig, METH_VARARGS, NULL},
25926  { (char *)"BgpConfig_in_filters4_set", _wrap_BgpConfig_in_filters4_set, METH_VARARGS, NULL},
25927  { (char *)"BgpConfig_in_filters4_get", _wrap_BgpConfig_in_filters4_get, METH_VARARGS, NULL},
25928  { (char *)"BgpConfig_out_filters4_set", _wrap_BgpConfig_out_filters4_set, METH_VARARGS, NULL},
25929  { (char *)"BgpConfig_out_filters4_get", _wrap_BgpConfig_out_filters4_get, METH_VARARGS, NULL},
25930  { (char *)"BgpConfig_in_filters6_set", _wrap_BgpConfig_in_filters6_set, METH_VARARGS, NULL},
25931  { (char *)"BgpConfig_in_filters6_get", _wrap_BgpConfig_in_filters6_get, METH_VARARGS, NULL},
25932  { (char *)"BgpConfig_out_filters6_set", _wrap_BgpConfig_out_filters6_set, METH_VARARGS, NULL},
25933  { (char *)"BgpConfig_out_filters6_get", _wrap_BgpConfig_out_filters6_get, METH_VARARGS, NULL},
25934  { (char *)"BgpConfig_out_handler_set", _wrap_BgpConfig_out_handler_set, METH_VARARGS, NULL},
25935  { (char *)"BgpConfig_out_handler_get", _wrap_BgpConfig_out_handler_get, METH_VARARGS, NULL},
25936  { (char *)"BgpConfig_log_handler_set", _wrap_BgpConfig_log_handler_set, METH_VARARGS, NULL},
25937  { (char *)"BgpConfig_log_handler_get", _wrap_BgpConfig_log_handler_get, METH_VARARGS, NULL},
25938  { (char *)"BgpConfig_rib4_set", _wrap_BgpConfig_rib4_set, METH_VARARGS, NULL},
25939  { (char *)"BgpConfig_rib4_get", _wrap_BgpConfig_rib4_get, METH_VARARGS, NULL},
25940  { (char *)"BgpConfig_rib6_set", _wrap_BgpConfig_rib6_set, METH_VARARGS, NULL},
25941  { (char *)"BgpConfig_rib6_get", _wrap_BgpConfig_rib6_get, METH_VARARGS, NULL},
25942  { (char *)"BgpConfig_rev_bus_set", _wrap_BgpConfig_rev_bus_set, METH_VARARGS, NULL},
25943  { (char *)"BgpConfig_rev_bus_get", _wrap_BgpConfig_rev_bus_get, METH_VARARGS, NULL},
25944  { (char *)"BgpConfig_no_collision_detection_set", _wrap_BgpConfig_no_collision_detection_set, METH_VARARGS, NULL},
25945  { (char *)"BgpConfig_no_collision_detection_get", _wrap_BgpConfig_no_collision_detection_get, METH_VARARGS, NULL},
25946  { (char *)"BgpConfig_use_4b_asn_set", _wrap_BgpConfig_use_4b_asn_set, METH_VARARGS, NULL},
25947  { (char *)"BgpConfig_use_4b_asn_get", _wrap_BgpConfig_use_4b_asn_get, METH_VARARGS, NULL},
25948  { (char *)"BgpConfig_mp_bgp_ipv4_set", _wrap_BgpConfig_mp_bgp_ipv4_set, METH_VARARGS, NULL},
25949  { (char *)"BgpConfig_mp_bgp_ipv4_get", _wrap_BgpConfig_mp_bgp_ipv4_get, METH_VARARGS, NULL},
25950  { (char *)"BgpConfig_mp_bgp_ipv6_set", _wrap_BgpConfig_mp_bgp_ipv6_set, METH_VARARGS, NULL},
25951  { (char *)"BgpConfig_mp_bgp_ipv6_get", _wrap_BgpConfig_mp_bgp_ipv6_get, METH_VARARGS, NULL},
25952  { (char *)"BgpConfig_asn_set", _wrap_BgpConfig_asn_set, METH_VARARGS, NULL},
25953  { (char *)"BgpConfig_asn_get", _wrap_BgpConfig_asn_get, METH_VARARGS, NULL},
25954  { (char *)"BgpConfig_peer_asn_set", _wrap_BgpConfig_peer_asn_set, METH_VARARGS, NULL},
25955  { (char *)"BgpConfig_peer_asn_get", _wrap_BgpConfig_peer_asn_get, METH_VARARGS, NULL},
25956  { (char *)"BgpConfig_router_id_set", _wrap_BgpConfig_router_id_set, METH_VARARGS, NULL},
25957  { (char *)"BgpConfig_router_id_get", _wrap_BgpConfig_router_id_get, METH_VARARGS, NULL},
25958  { (char *)"BgpConfig_peering_lan4_set", _wrap_BgpConfig_peering_lan4_set, METH_VARARGS, NULL},
25959  { (char *)"BgpConfig_peering_lan4_get", _wrap_BgpConfig_peering_lan4_get, METH_VARARGS, NULL},
25960  { (char *)"BgpConfig_peering_lan6_set", _wrap_BgpConfig_peering_lan6_set, METH_VARARGS, NULL},
25961  { (char *)"BgpConfig_peering_lan6_get", _wrap_BgpConfig_peering_lan6_get, METH_VARARGS, NULL},
25962  { (char *)"BgpConfig_no_nexthop_check4_set", _wrap_BgpConfig_no_nexthop_check4_set, METH_VARARGS, NULL},
25963  { (char *)"BgpConfig_no_nexthop_check4_get", _wrap_BgpConfig_no_nexthop_check4_get, METH_VARARGS, NULL},
25964  { (char *)"BgpConfig_default_nexthop4_set", _wrap_BgpConfig_default_nexthop4_set, METH_VARARGS, NULL},
25965  { (char *)"BgpConfig_default_nexthop4_get", _wrap_BgpConfig_default_nexthop4_get, METH_VARARGS, NULL},
25966  { (char *)"BgpConfig_forced_default_nexthop4_set", _wrap_BgpConfig_forced_default_nexthop4_set, METH_VARARGS, NULL},
25967  { (char *)"BgpConfig_forced_default_nexthop4_get", _wrap_BgpConfig_forced_default_nexthop4_get, METH_VARARGS, NULL},
25968  { (char *)"BgpConfig_no_nexthop_check6_set", _wrap_BgpConfig_no_nexthop_check6_set, METH_VARARGS, NULL},
25969  { (char *)"BgpConfig_no_nexthop_check6_get", _wrap_BgpConfig_no_nexthop_check6_get, METH_VARARGS, NULL},
25970  { (char *)"BgpConfig_default_nexthop6_global_set", _wrap_BgpConfig_default_nexthop6_global_set, METH_VARARGS, NULL},
25971  { (char *)"BgpConfig_default_nexthop6_global_get", _wrap_BgpConfig_default_nexthop6_global_get, METH_VARARGS, NULL},
25972  { (char *)"BgpConfig_default_nexthop6_linklocal_set", _wrap_BgpConfig_default_nexthop6_linklocal_set, METH_VARARGS, NULL},
25973  { (char *)"BgpConfig_default_nexthop6_linklocal_get", _wrap_BgpConfig_default_nexthop6_linklocal_get, METH_VARARGS, NULL},
25974  { (char *)"BgpConfig_forced_default_nexthop6_set", _wrap_BgpConfig_forced_default_nexthop6_set, METH_VARARGS, NULL},
25975  { (char *)"BgpConfig_forced_default_nexthop6_get", _wrap_BgpConfig_forced_default_nexthop6_get, METH_VARARGS, NULL},
25976  { (char *)"BgpConfig_hold_timer_set", _wrap_BgpConfig_hold_timer_set, METH_VARARGS, NULL},
25977  { (char *)"BgpConfig_hold_timer_get", _wrap_BgpConfig_hold_timer_get, METH_VARARGS, NULL},
25978  { (char *)"BgpConfig_clock_set", _wrap_BgpConfig_clock_set, METH_VARARGS, NULL},
25979  { (char *)"BgpConfig_clock_get", _wrap_BgpConfig_clock_get, METH_VARARGS, NULL},
25980  { (char *)"BgpConfig_allow_local_as_set", _wrap_BgpConfig_allow_local_as_set, METH_VARARGS, NULL},
25981  { (char *)"BgpConfig_allow_local_as_get", _wrap_BgpConfig_allow_local_as_get, METH_VARARGS, NULL},
25982  { (char *)"BgpConfig_weight_set", _wrap_BgpConfig_weight_set, METH_VARARGS, NULL},
25983  { (char *)"BgpConfig_weight_get", _wrap_BgpConfig_weight_get, METH_VARARGS, NULL},
25984  { (char *)"BgpConfig_no_autotick_set", _wrap_BgpConfig_no_autotick_set, METH_VARARGS, NULL},
25985  { (char *)"BgpConfig_no_autotick_get", _wrap_BgpConfig_no_autotick_get, METH_VARARGS, NULL},
25986  { (char *)"delete_BgpConfig", _wrap_delete_BgpConfig, METH_VARARGS, NULL},
25987  { (char *)"BgpConfig_swigregister", BgpConfig_swigregister, METH_VARARGS, NULL},
25988  { (char *)"new_BgpFsm", _wrap_new_BgpFsm, METH_VARARGS, NULL},
25989  { (char *)"delete_BgpFsm", _wrap_delete_BgpFsm, METH_VARARGS, NULL},
25990  { (char *)"BgpFsm_getAsn", _wrap_BgpFsm_getAsn, METH_VARARGS, NULL},
25991  { (char *)"BgpFsm_getBgpId", _wrap_BgpFsm_getBgpId, METH_VARARGS, NULL},
25992  { (char *)"BgpFsm_getPeerAsn", _wrap_BgpFsm_getPeerAsn, METH_VARARGS, NULL},
25993  { (char *)"BgpFsm_getPeerBgpId", _wrap_BgpFsm_getPeerBgpId, METH_VARARGS, NULL},
25994  { (char *)"BgpFsm_getHoldTimer", _wrap_BgpFsm_getHoldTimer, METH_VARARGS, NULL},
25995  { (char *)"BgpFsm_getRib4", _wrap_BgpFsm_getRib4, METH_VARARGS, NULL},
25996  { (char *)"BgpFsm_getRib6", _wrap_BgpFsm_getRib6, METH_VARARGS, NULL},
25997  { (char *)"BgpFsm_getState", _wrap_BgpFsm_getState, METH_VARARGS, NULL},
25998  { (char *)"BgpFsm_start", _wrap_BgpFsm_start, METH_VARARGS, NULL},
25999  { (char *)"BgpFsm_stop", _wrap_BgpFsm_stop, METH_VARARGS, NULL},
26000  { (char *)"BgpFsm_run", _wrap_BgpFsm_run, METH_VARARGS, NULL},
26001  { (char *)"BgpFsm_tick", _wrap_BgpFsm_tick, METH_VARARGS, NULL},
26002  { (char *)"BgpFsm_resetSoft", _wrap_BgpFsm_resetSoft, METH_VARARGS, NULL},
26003  { (char *)"BgpFsm_resetHard", _wrap_BgpFsm_resetHard, METH_VARARGS, NULL},
26004  { (char *)"BgpFsm_swigregister", BgpFsm_swigregister, METH_VARARGS, NULL},
26005  { (char *)"new_BgpLogHandler", _wrap_new_BgpLogHandler, METH_VARARGS, NULL},
26006  { (char *)"BgpLogHandler_log", _wrap_BgpLogHandler_log, METH_VARARGS, NULL},
26007  { (char *)"BgpLogHandler_setLogLevel", _wrap_BgpLogHandler_setLogLevel, METH_VARARGS, NULL},
26008  { (char *)"BgpLogHandler_getLogLevel", _wrap_BgpLogHandler_getLogLevel, METH_VARARGS, NULL},
26009  { (char *)"delete_BgpLogHandler", _wrap_delete_BgpLogHandler, METH_VARARGS, NULL},
26010  { (char *)"BgpLogHandler_swigregister", BgpLogHandler_swigregister, METH_VARARGS, NULL},
26011  { (char *)"BgpMessage_parse", _wrap_BgpMessage_parse, METH_VARARGS, NULL},
26012  { (char *)"BgpMessage_write", _wrap_BgpMessage_write, METH_VARARGS, NULL},
26013  { (char *)"BgpMessage_type_set", _wrap_BgpMessage_type_set, METH_VARARGS, NULL},
26014  { (char *)"BgpMessage_type_get", _wrap_BgpMessage_type_get, METH_VARARGS, NULL},
26015  { (char *)"delete_BgpMessage", _wrap_delete_BgpMessage, METH_VARARGS, NULL},
26016  { (char *)"BgpMessage_swigregister", BgpMessage_swigregister, METH_VARARGS, NULL},
26017  { (char *)"new_BgpBadMessage", _wrap_new_BgpBadMessage, METH_VARARGS, NULL},
26018  { (char *)"BgpBadMessage_doPrint", _wrap_BgpBadMessage_doPrint, METH_VARARGS, NULL},
26019  { (char *)"BgpBadMessage_parse", _wrap_BgpBadMessage_parse, METH_VARARGS, NULL},
26020  { (char *)"BgpBadMessage_write", _wrap_BgpBadMessage_write, METH_VARARGS, NULL},
26021  { (char *)"delete_BgpBadMessage", _wrap_delete_BgpBadMessage, METH_VARARGS, NULL},
26022  { (char *)"BgpBadMessage_swigregister", BgpBadMessage_swigregister, METH_VARARGS, NULL},
26023  { (char *)"new_BgpKeepaliveMessage", _wrap_new_BgpKeepaliveMessage, METH_VARARGS, NULL},
26024  { (char *)"BgpKeepaliveMessage_doPrint", _wrap_BgpKeepaliveMessage_doPrint, METH_VARARGS, NULL},
26025  { (char *)"BgpKeepaliveMessage_parse", _wrap_BgpKeepaliveMessage_parse, METH_VARARGS, NULL},
26026  { (char *)"BgpKeepaliveMessage_write", _wrap_BgpKeepaliveMessage_write, METH_VARARGS, NULL},
26027  { (char *)"delete_BgpKeepaliveMessage", _wrap_delete_BgpKeepaliveMessage, METH_VARARGS, NULL},
26028  { (char *)"BgpKeepaliveMessage_swigregister", BgpKeepaliveMessage_swigregister, METH_VARARGS, NULL},
26029  { (char *)"new_BgpNotificationMessage", _wrap_new_BgpNotificationMessage, METH_VARARGS, NULL},
26030  { (char *)"delete_BgpNotificationMessage", _wrap_delete_BgpNotificationMessage, METH_VARARGS, NULL},
26031  { (char *)"BgpNotificationMessage_errcode_set", _wrap_BgpNotificationMessage_errcode_set, METH_VARARGS, NULL},
26032  { (char *)"BgpNotificationMessage_errcode_get", _wrap_BgpNotificationMessage_errcode_get, METH_VARARGS, NULL},
26033  { (char *)"BgpNotificationMessage_subcode_set", _wrap_BgpNotificationMessage_subcode_set, METH_VARARGS, NULL},
26034  { (char *)"BgpNotificationMessage_subcode_get", _wrap_BgpNotificationMessage_subcode_get, METH_VARARGS, NULL},
26035  { (char *)"BgpNotificationMessage_data_set", _wrap_BgpNotificationMessage_data_set, METH_VARARGS, NULL},
26036  { (char *)"BgpNotificationMessage_data_get", _wrap_BgpNotificationMessage_data_get, METH_VARARGS, NULL},
26037  { (char *)"BgpNotificationMessage_data_len_set", _wrap_BgpNotificationMessage_data_len_set, METH_VARARGS, NULL},
26038  { (char *)"BgpNotificationMessage_data_len_get", _wrap_BgpNotificationMessage_data_len_get, METH_VARARGS, NULL},
26039  { (char *)"BgpNotificationMessage_doPrint", _wrap_BgpNotificationMessage_doPrint, METH_VARARGS, NULL},
26040  { (char *)"BgpNotificationMessage_parse", _wrap_BgpNotificationMessage_parse, METH_VARARGS, NULL},
26041  { (char *)"BgpNotificationMessage_write", _wrap_BgpNotificationMessage_write, METH_VARARGS, NULL},
26042  { (char *)"BgpNotificationMessage_swigregister", BgpNotificationMessage_swigregister, METH_VARARGS, NULL},
26043  { (char *)"new_BgpOpenMessage", _wrap_new_BgpOpenMessage, METH_VARARGS, NULL},
26044  { (char *)"delete_BgpOpenMessage", _wrap_delete_BgpOpenMessage, METH_VARARGS, NULL},
26045  { (char *)"BgpOpenMessage_version_set", _wrap_BgpOpenMessage_version_set, METH_VARARGS, NULL},
26046  { (char *)"BgpOpenMessage_version_get", _wrap_BgpOpenMessage_version_get, METH_VARARGS, NULL},
26047  { (char *)"BgpOpenMessage_my_asn_set", _wrap_BgpOpenMessage_my_asn_set, METH_VARARGS, NULL},
26048  { (char *)"BgpOpenMessage_my_asn_get", _wrap_BgpOpenMessage_my_asn_get, METH_VARARGS, NULL},
26049  { (char *)"BgpOpenMessage_hold_time_set", _wrap_BgpOpenMessage_hold_time_set, METH_VARARGS, NULL},
26050  { (char *)"BgpOpenMessage_hold_time_get", _wrap_BgpOpenMessage_hold_time_get, METH_VARARGS, NULL},
26051  { (char *)"BgpOpenMessage_bgp_id_set", _wrap_BgpOpenMessage_bgp_id_set, METH_VARARGS, NULL},
26052  { (char *)"BgpOpenMessage_bgp_id_get", _wrap_BgpOpenMessage_bgp_id_get, METH_VARARGS, NULL},
26053  { (char *)"BgpOpenMessage_setAsn", _wrap_BgpOpenMessage_setAsn, METH_VARARGS, NULL},
26054  { (char *)"BgpOpenMessage_getAsn", _wrap_BgpOpenMessage_getAsn, METH_VARARGS, NULL},
26055  { (char *)"BgpOpenMessage_hasCapability", _wrap_BgpOpenMessage_hasCapability, METH_VARARGS, NULL},
26056  { (char *)"BgpOpenMessage_addCapability", _wrap_BgpOpenMessage_addCapability, METH_VARARGS, NULL},
26057  { (char *)"BgpOpenMessage_doPrint", _wrap_BgpOpenMessage_doPrint, METH_VARARGS, NULL},
26058  { (char *)"BgpOpenMessage_parse", _wrap_BgpOpenMessage_parse, METH_VARARGS, NULL},
26059  { (char *)"BgpOpenMessage_write", _wrap_BgpOpenMessage_write, METH_VARARGS, NULL},
26060  { (char *)"BgpOpenMessage_getCapabilities", _wrap_BgpOpenMessage_getCapabilities, METH_VARARGS, NULL},
26061  { (char *)"BgpOpenMessage_swigregister", BgpOpenMessage_swigregister, METH_VARARGS, NULL},
26062  { (char *)"BgpOutHandler_handleOut", _wrap_BgpOutHandler_handleOut, METH_VARARGS, NULL},
26063  { (char *)"BgpOutHandler_notifyStateChange", _wrap_BgpOutHandler_notifyStateChange, METH_VARARGS, NULL},
26064  { (char *)"delete_BgpOutHandler", _wrap_delete_BgpOutHandler, METH_VARARGS, NULL},
26065  { (char *)"BgpOutHandler_swigregister", BgpOutHandler_swigregister, METH_VARARGS, NULL},
26066  { (char *)"new_FdOutHandler", _wrap_new_FdOutHandler, METH_VARARGS, NULL},
26067  { (char *)"FdOutHandler_handleOut", _wrap_FdOutHandler_handleOut, METH_VARARGS, NULL},
26068  { (char *)"delete_FdOutHandler", _wrap_delete_FdOutHandler, METH_VARARGS, NULL},
26069  { (char *)"FdOutHandler_swigregister", FdOutHandler_swigregister, METH_VARARGS, NULL},
26070  { (char *)"new_BgpPacket", _wrap_new_BgpPacket, METH_VARARGS, NULL},
26071  { (char *)"delete_BgpPacket", _wrap_delete_BgpPacket, METH_VARARGS, NULL},
26072  { (char *)"BgpPacket_doPrint", _wrap_BgpPacket_doPrint, METH_VARARGS, NULL},
26073  { (char *)"BgpPacket_parse", _wrap_BgpPacket_parse, METH_VARARGS, NULL},
26074  { (char *)"BgpPacket_write", _wrap_BgpPacket_write, METH_VARARGS, NULL},
26075  { (char *)"BgpPacket_getMessage", _wrap_BgpPacket_getMessage, METH_VARARGS, NULL},
26076  { (char *)"BgpPacket_swigregister", BgpPacket_swigregister, METH_VARARGS, NULL},
26077  { (char *)"BgpPathAttrib_optional_set", _wrap_BgpPathAttrib_optional_set, METH_VARARGS, NULL},
26078  { (char *)"BgpPathAttrib_optional_get", _wrap_BgpPathAttrib_optional_get, METH_VARARGS, NULL},
26079  { (char *)"BgpPathAttrib_transitive_set", _wrap_BgpPathAttrib_transitive_set, METH_VARARGS, NULL},
26080  { (char *)"BgpPathAttrib_transitive_get", _wrap_BgpPathAttrib_transitive_get, METH_VARARGS, NULL},
26081  { (char *)"BgpPathAttrib_partial_set", _wrap_BgpPathAttrib_partial_set, METH_VARARGS, NULL},
26082  { (char *)"BgpPathAttrib_partial_get", _wrap_BgpPathAttrib_partial_get, METH_VARARGS, NULL},
26083  { (char *)"BgpPathAttrib_extended_set", _wrap_BgpPathAttrib_extended_set, METH_VARARGS, NULL},
26084  { (char *)"BgpPathAttrib_extended_get", _wrap_BgpPathAttrib_extended_get, METH_VARARGS, NULL},
26085  { (char *)"BgpPathAttrib_type_code_set", _wrap_BgpPathAttrib_type_code_set, METH_VARARGS, NULL},
26086  { (char *)"BgpPathAttrib_type_code_get", _wrap_BgpPathAttrib_type_code_get, METH_VARARGS, NULL},
26087  { (char *)"new_BgpPathAttrib", _wrap_new_BgpPathAttrib, METH_VARARGS, NULL},
26088  { (char *)"BgpPathAttrib_GetTypeFromBuffer", _wrap_BgpPathAttrib_GetTypeFromBuffer, METH_VARARGS, NULL},
26089  { (char *)"BgpPathAttrib_doPrint", _wrap_BgpPathAttrib_doPrint, METH_VARARGS, NULL},
26090  { (char *)"BgpPathAttrib_parse", _wrap_BgpPathAttrib_parse, METH_VARARGS, NULL},
26091  { (char *)"BgpPathAttrib_write", _wrap_BgpPathAttrib_write, METH_VARARGS, NULL},
26092  { (char *)"BgpPathAttrib_length", _wrap_BgpPathAttrib_length, METH_VARARGS, NULL},
26093  { (char *)"BgpPathAttrib_clone", _wrap_BgpPathAttrib_clone, METH_VARARGS, NULL},
26094  { (char *)"delete_BgpPathAttrib", _wrap_delete_BgpPathAttrib, METH_VARARGS, NULL},
26095  { (char *)"BgpPathAttrib_swigregister", BgpPathAttrib_swigregister, METH_VARARGS, NULL},
26096  { (char *)"new_BgpPathAttribOrigin", _wrap_new_BgpPathAttribOrigin, METH_VARARGS, NULL},
26097  { (char *)"BgpPathAttribOrigin_origin_set", _wrap_BgpPathAttribOrigin_origin_set, METH_VARARGS, NULL},
26098  { (char *)"BgpPathAttribOrigin_origin_get", _wrap_BgpPathAttribOrigin_origin_get, METH_VARARGS, NULL},
26099  { (char *)"BgpPathAttribOrigin_clone", _wrap_BgpPathAttribOrigin_clone, METH_VARARGS, NULL},
26100  { (char *)"BgpPathAttribOrigin_parse", _wrap_BgpPathAttribOrigin_parse, METH_VARARGS, NULL},
26101  { (char *)"BgpPathAttribOrigin_write", _wrap_BgpPathAttribOrigin_write, METH_VARARGS, NULL},
26102  { (char *)"BgpPathAttribOrigin_doPrint", _wrap_BgpPathAttribOrigin_doPrint, METH_VARARGS, NULL},
26103  { (char *)"BgpPathAttribOrigin_length", _wrap_BgpPathAttribOrigin_length, METH_VARARGS, NULL},
26104  { (char *)"delete_BgpPathAttribOrigin", _wrap_delete_BgpPathAttribOrigin, METH_VARARGS, NULL},
26105  { (char *)"BgpPathAttribOrigin_swigregister", BgpPathAttribOrigin_swigregister, METH_VARARGS, NULL},
26106  { (char *)"new_BgpAsPathSegment", _wrap_new_BgpAsPathSegment, METH_VARARGS, NULL},
26107  { (char *)"BgpAsPathSegment_is_4b_set", _wrap_BgpAsPathSegment_is_4b_set, METH_VARARGS, NULL},
26108  { (char *)"BgpAsPathSegment_is_4b_get", _wrap_BgpAsPathSegment_is_4b_get, METH_VARARGS, NULL},
26109  { (char *)"BgpAsPathSegment_type_set", _wrap_BgpAsPathSegment_type_set, METH_VARARGS, NULL},
26110  { (char *)"BgpAsPathSegment_type_get", _wrap_BgpAsPathSegment_type_get, METH_VARARGS, NULL},
26111  { (char *)"BgpAsPathSegment_getCount", _wrap_BgpAsPathSegment_getCount, METH_VARARGS, NULL},
26112  { (char *)"BgpAsPathSegment_prepend", _wrap_BgpAsPathSegment_prepend, METH_VARARGS, NULL},
26113  { (char *)"BgpAsPathSegment_value_set", _wrap_BgpAsPathSegment_value_set, METH_VARARGS, NULL},
26114  { (char *)"BgpAsPathSegment_value_get", _wrap_BgpAsPathSegment_value_get, METH_VARARGS, NULL},
26115  { (char *)"delete_BgpAsPathSegment", _wrap_delete_BgpAsPathSegment, METH_VARARGS, NULL},
26116  { (char *)"BgpAsPathSegment_swigregister", BgpAsPathSegment_swigregister, METH_VARARGS, NULL},
26117  { (char *)"new_BgpPathAttribAsPath", _wrap_new_BgpPathAttribAsPath, METH_VARARGS, NULL},
26118  { (char *)"BgpPathAttribAsPath_clone", _wrap_BgpPathAttribAsPath_clone, METH_VARARGS, NULL},
26119  { (char *)"BgpPathAttribAsPath_as_paths_set", _wrap_BgpPathAttribAsPath_as_paths_set, METH_VARARGS, NULL},
26120  { (char *)"BgpPathAttribAsPath_as_paths_get", _wrap_BgpPathAttribAsPath_as_paths_get, METH_VARARGS, NULL},
26121  { (char *)"BgpPathAttribAsPath_is_4b_set", _wrap_BgpPathAttribAsPath_is_4b_set, METH_VARARGS, NULL},
26122  { (char *)"BgpPathAttribAsPath_is_4b_get", _wrap_BgpPathAttribAsPath_is_4b_get, METH_VARARGS, NULL},
26123  { (char *)"BgpPathAttribAsPath_prepend", _wrap_BgpPathAttribAsPath_prepend, METH_VARARGS, NULL},
26124  { (char *)"BgpPathAttribAsPath_parse", _wrap_BgpPathAttribAsPath_parse, METH_VARARGS, NULL},
26125  { (char *)"BgpPathAttribAsPath_write", _wrap_BgpPathAttribAsPath_write, METH_VARARGS, NULL},
26126  { (char *)"BgpPathAttribAsPath_doPrint", _wrap_BgpPathAttribAsPath_doPrint, METH_VARARGS, NULL},
26127  { (char *)"BgpPathAttribAsPath_length", _wrap_BgpPathAttribAsPath_length, METH_VARARGS, NULL},
26128  { (char *)"delete_BgpPathAttribAsPath", _wrap_delete_BgpPathAttribAsPath, METH_VARARGS, NULL},
26129  { (char *)"BgpPathAttribAsPath_swigregister", BgpPathAttribAsPath_swigregister, METH_VARARGS, NULL},
26130  { (char *)"new_BgpPathAttribNexthop", _wrap_new_BgpPathAttribNexthop, METH_VARARGS, NULL},
26131  { (char *)"BgpPathAttribNexthop_next_hop_set", _wrap_BgpPathAttribNexthop_next_hop_set, METH_VARARGS, NULL},
26132  { (char *)"BgpPathAttribNexthop_next_hop_get", _wrap_BgpPathAttribNexthop_next_hop_get, METH_VARARGS, NULL},
26133  { (char *)"BgpPathAttribNexthop_clone", _wrap_BgpPathAttribNexthop_clone, METH_VARARGS, NULL},
26134  { (char *)"BgpPathAttribNexthop_parse", _wrap_BgpPathAttribNexthop_parse, METH_VARARGS, NULL},
26135  { (char *)"BgpPathAttribNexthop_write", _wrap_BgpPathAttribNexthop_write, METH_VARARGS, NULL},
26136  { (char *)"BgpPathAttribNexthop_doPrint", _wrap_BgpPathAttribNexthop_doPrint, METH_VARARGS, NULL},
26137  { (char *)"BgpPathAttribNexthop_length", _wrap_BgpPathAttribNexthop_length, METH_VARARGS, NULL},
26138  { (char *)"delete_BgpPathAttribNexthop", _wrap_delete_BgpPathAttribNexthop, METH_VARARGS, NULL},
26139  { (char *)"BgpPathAttribNexthop_swigregister", BgpPathAttribNexthop_swigregister, METH_VARARGS, NULL},
26140  { (char *)"new_BgpPathAttribMed", _wrap_new_BgpPathAttribMed, METH_VARARGS, NULL},
26141  { (char *)"BgpPathAttribMed_med_set", _wrap_BgpPathAttribMed_med_set, METH_VARARGS, NULL},
26142  { (char *)"BgpPathAttribMed_med_get", _wrap_BgpPathAttribMed_med_get, METH_VARARGS, NULL},
26143  { (char *)"BgpPathAttribMed_clone", _wrap_BgpPathAttribMed_clone, METH_VARARGS, NULL},
26144  { (char *)"BgpPathAttribMed_parse", _wrap_BgpPathAttribMed_parse, METH_VARARGS, NULL},
26145  { (char *)"BgpPathAttribMed_write", _wrap_BgpPathAttribMed_write, METH_VARARGS, NULL},
26146  { (char *)"BgpPathAttribMed_doPrint", _wrap_BgpPathAttribMed_doPrint, METH_VARARGS, NULL},
26147  { (char *)"BgpPathAttribMed_length", _wrap_BgpPathAttribMed_length, METH_VARARGS, NULL},
26148  { (char *)"delete_BgpPathAttribMed", _wrap_delete_BgpPathAttribMed, METH_VARARGS, NULL},
26149  { (char *)"BgpPathAttribMed_swigregister", BgpPathAttribMed_swigregister, METH_VARARGS, NULL},
26150  { (char *)"new_BgpPathAttribLocalPref", _wrap_new_BgpPathAttribLocalPref, METH_VARARGS, NULL},
26151  { (char *)"BgpPathAttribLocalPref_local_pref_set", _wrap_BgpPathAttribLocalPref_local_pref_set, METH_VARARGS, NULL},
26152  { (char *)"BgpPathAttribLocalPref_local_pref_get", _wrap_BgpPathAttribLocalPref_local_pref_get, METH_VARARGS, NULL},
26153  { (char *)"BgpPathAttribLocalPref_clone", _wrap_BgpPathAttribLocalPref_clone, METH_VARARGS, NULL},
26154  { (char *)"BgpPathAttribLocalPref_parse", _wrap_BgpPathAttribLocalPref_parse, METH_VARARGS, NULL},
26155  { (char *)"BgpPathAttribLocalPref_write", _wrap_BgpPathAttribLocalPref_write, METH_VARARGS, NULL},
26156  { (char *)"BgpPathAttribLocalPref_doPrint", _wrap_BgpPathAttribLocalPref_doPrint, METH_VARARGS, NULL},
26157  { (char *)"BgpPathAttribLocalPref_length", _wrap_BgpPathAttribLocalPref_length, METH_VARARGS, NULL},
26158  { (char *)"delete_BgpPathAttribLocalPref", _wrap_delete_BgpPathAttribLocalPref, METH_VARARGS, NULL},
26159  { (char *)"BgpPathAttribLocalPref_swigregister", BgpPathAttribLocalPref_swigregister, METH_VARARGS, NULL},
26160  { (char *)"new_BgpPathAttribAtomicAggregate", _wrap_new_BgpPathAttribAtomicAggregate, METH_VARARGS, NULL},
26161  { (char *)"BgpPathAttribAtomicAggregate_clone", _wrap_BgpPathAttribAtomicAggregate_clone, METH_VARARGS, NULL},
26162  { (char *)"BgpPathAttribAtomicAggregate_parse", _wrap_BgpPathAttribAtomicAggregate_parse, METH_VARARGS, NULL},
26163  { (char *)"BgpPathAttribAtomicAggregate_write", _wrap_BgpPathAttribAtomicAggregate_write, METH_VARARGS, NULL},
26164  { (char *)"BgpPathAttribAtomicAggregate_doPrint", _wrap_BgpPathAttribAtomicAggregate_doPrint, METH_VARARGS, NULL},
26165  { (char *)"BgpPathAttribAtomicAggregate_length", _wrap_BgpPathAttribAtomicAggregate_length, METH_VARARGS, NULL},
26166  { (char *)"delete_BgpPathAttribAtomicAggregate", _wrap_delete_BgpPathAttribAtomicAggregate, METH_VARARGS, NULL},
26167  { (char *)"BgpPathAttribAtomicAggregate_swigregister", BgpPathAttribAtomicAggregate_swigregister, METH_VARARGS, NULL},
26168  { (char *)"new_BgpPathAttribAggregator", _wrap_new_BgpPathAttribAggregator, METH_VARARGS, NULL},
26169  { (char *)"BgpPathAttribAggregator_aggregator_set", _wrap_BgpPathAttribAggregator_aggregator_set, METH_VARARGS, NULL},
26170  { (char *)"BgpPathAttribAggregator_aggregator_get", _wrap_BgpPathAttribAggregator_aggregator_get, METH_VARARGS, NULL},
26171  { (char *)"BgpPathAttribAggregator_aggregator_asn_set", _wrap_BgpPathAttribAggregator_aggregator_asn_set, METH_VARARGS, NULL},
26172  { (char *)"BgpPathAttribAggregator_aggregator_asn_get", _wrap_BgpPathAttribAggregator_aggregator_asn_get, METH_VARARGS, NULL},
26173  { (char *)"BgpPathAttribAggregator_is_4b_set", _wrap_BgpPathAttribAggregator_is_4b_set, METH_VARARGS, NULL},
26174  { (char *)"BgpPathAttribAggregator_is_4b_get", _wrap_BgpPathAttribAggregator_is_4b_get, METH_VARARGS, NULL},
26175  { (char *)"BgpPathAttribAggregator_clone", _wrap_BgpPathAttribAggregator_clone, METH_VARARGS, NULL},
26176  { (char *)"BgpPathAttribAggregator_parse", _wrap_BgpPathAttribAggregator_parse, METH_VARARGS, NULL},
26177  { (char *)"BgpPathAttribAggregator_write", _wrap_BgpPathAttribAggregator_write, METH_VARARGS, NULL},
26178  { (char *)"BgpPathAttribAggregator_doPrint", _wrap_BgpPathAttribAggregator_doPrint, METH_VARARGS, NULL},
26179  { (char *)"BgpPathAttribAggregator_length", _wrap_BgpPathAttribAggregator_length, METH_VARARGS, NULL},
26180  { (char *)"delete_BgpPathAttribAggregator", _wrap_delete_BgpPathAttribAggregator, METH_VARARGS, NULL},
26181  { (char *)"BgpPathAttribAggregator_swigregister", BgpPathAttribAggregator_swigregister, METH_VARARGS, NULL},
26182  { (char *)"new_BgpPathAttribAs4Path", _wrap_new_BgpPathAttribAs4Path, METH_VARARGS, NULL},
26183  { (char *)"BgpPathAttribAs4Path_as4_paths_set", _wrap_BgpPathAttribAs4Path_as4_paths_set, METH_VARARGS, NULL},
26184  { (char *)"BgpPathAttribAs4Path_as4_paths_get", _wrap_BgpPathAttribAs4Path_as4_paths_get, METH_VARARGS, NULL},
26185  { (char *)"BgpPathAttribAs4Path_prepend", _wrap_BgpPathAttribAs4Path_prepend, METH_VARARGS, NULL},
26186  { (char *)"BgpPathAttribAs4Path_clone", _wrap_BgpPathAttribAs4Path_clone, METH_VARARGS, NULL},
26187  { (char *)"BgpPathAttribAs4Path_parse", _wrap_BgpPathAttribAs4Path_parse, METH_VARARGS, NULL},
26188  { (char *)"BgpPathAttribAs4Path_write", _wrap_BgpPathAttribAs4Path_write, METH_VARARGS, NULL},
26189  { (char *)"BgpPathAttribAs4Path_doPrint", _wrap_BgpPathAttribAs4Path_doPrint, METH_VARARGS, NULL},
26190  { (char *)"BgpPathAttribAs4Path_length", _wrap_BgpPathAttribAs4Path_length, METH_VARARGS, NULL},
26191  { (char *)"delete_BgpPathAttribAs4Path", _wrap_delete_BgpPathAttribAs4Path, METH_VARARGS, NULL},
26192  { (char *)"BgpPathAttribAs4Path_swigregister", BgpPathAttribAs4Path_swigregister, METH_VARARGS, NULL},
26193  { (char *)"new_BgpPathAttribAs4Aggregator", _wrap_new_BgpPathAttribAs4Aggregator, METH_VARARGS, NULL},
26194  { (char *)"BgpPathAttribAs4Aggregator_aggregator_set", _wrap_BgpPathAttribAs4Aggregator_aggregator_set, METH_VARARGS, NULL},
26195  { (char *)"BgpPathAttribAs4Aggregator_aggregator_get", _wrap_BgpPathAttribAs4Aggregator_aggregator_get, METH_VARARGS, NULL},
26196  { (char *)"BgpPathAttribAs4Aggregator_aggregator_asn4_set", _wrap_BgpPathAttribAs4Aggregator_aggregator_asn4_set, METH_VARARGS, NULL},
26197  { (char *)"BgpPathAttribAs4Aggregator_aggregator_asn4_get", _wrap_BgpPathAttribAs4Aggregator_aggregator_asn4_get, METH_VARARGS, NULL},
26198  { (char *)"BgpPathAttribAs4Aggregator_clone", _wrap_BgpPathAttribAs4Aggregator_clone, METH_VARARGS, NULL},
26199  { (char *)"BgpPathAttribAs4Aggregator_parse", _wrap_BgpPathAttribAs4Aggregator_parse, METH_VARARGS, NULL},
26200  { (char *)"BgpPathAttribAs4Aggregator_write", _wrap_BgpPathAttribAs4Aggregator_write, METH_VARARGS, NULL},
26201  { (char *)"BgpPathAttribAs4Aggregator_doPrint", _wrap_BgpPathAttribAs4Aggregator_doPrint, METH_VARARGS, NULL},
26202  { (char *)"BgpPathAttribAs4Aggregator_length", _wrap_BgpPathAttribAs4Aggregator_length, METH_VARARGS, NULL},
26203  { (char *)"delete_BgpPathAttribAs4Aggregator", _wrap_delete_BgpPathAttribAs4Aggregator, METH_VARARGS, NULL},
26204  { (char *)"BgpPathAttribAs4Aggregator_swigregister", BgpPathAttribAs4Aggregator_swigregister, METH_VARARGS, NULL},
26205  { (char *)"new_BgpPathAttribCommunity", _wrap_new_BgpPathAttribCommunity, METH_VARARGS, NULL},
26206  { (char *)"BgpPathAttribCommunity_communites_set", _wrap_BgpPathAttribCommunity_communites_set, METH_VARARGS, NULL},
26207  { (char *)"BgpPathAttribCommunity_communites_get", _wrap_BgpPathAttribCommunity_communites_get, METH_VARARGS, NULL},
26208  { (char *)"BgpPathAttribCommunity_clone", _wrap_BgpPathAttribCommunity_clone, METH_VARARGS, NULL},
26209  { (char *)"BgpPathAttribCommunity_parse", _wrap_BgpPathAttribCommunity_parse, METH_VARARGS, NULL},
26210  { (char *)"BgpPathAttribCommunity_write", _wrap_BgpPathAttribCommunity_write, METH_VARARGS, NULL},
26211  { (char *)"BgpPathAttribCommunity_doPrint", _wrap_BgpPathAttribCommunity_doPrint, METH_VARARGS, NULL},
26212  { (char *)"BgpPathAttribCommunity_length", _wrap_BgpPathAttribCommunity_length, METH_VARARGS, NULL},
26213  { (char *)"delete_BgpPathAttribCommunity", _wrap_delete_BgpPathAttribCommunity, METH_VARARGS, NULL},
26214  { (char *)"BgpPathAttribCommunity_swigregister", BgpPathAttribCommunity_swigregister, METH_VARARGS, NULL},
26215  { (char *)"new_BgpPathAttribMpNlriBase", _wrap_new_BgpPathAttribMpNlriBase, METH_VARARGS, NULL},
26216  { (char *)"BgpPathAttribMpNlriBase_GetAfiFromBuffer", _wrap_BgpPathAttribMpNlriBase_GetAfiFromBuffer, METH_VARARGS, NULL},
26217  { (char *)"BgpPathAttribMpNlriBase_afi_set", _wrap_BgpPathAttribMpNlriBase_afi_set, METH_VARARGS, NULL},
26218  { (char *)"BgpPathAttribMpNlriBase_afi_get", _wrap_BgpPathAttribMpNlriBase_afi_get, METH_VARARGS, NULL},
26219  { (char *)"BgpPathAttribMpNlriBase_safi_set", _wrap_BgpPathAttribMpNlriBase_safi_set, METH_VARARGS, NULL},
26220  { (char *)"BgpPathAttribMpNlriBase_safi_get", _wrap_BgpPathAttribMpNlriBase_safi_get, METH_VARARGS, NULL},
26221  { (char *)"delete_BgpPathAttribMpNlriBase", _wrap_delete_BgpPathAttribMpNlriBase, METH_VARARGS, NULL},
26222  { (char *)"BgpPathAttribMpNlriBase_swigregister", BgpPathAttribMpNlriBase_swigregister, METH_VARARGS, NULL},
26223  { (char *)"new_BgpPathAttribMpReachNlriIpv6", _wrap_new_BgpPathAttribMpReachNlriIpv6, METH_VARARGS, NULL},
26224  { (char *)"BgpPathAttribMpReachNlriIpv6_nexthop_global_set", _wrap_BgpPathAttribMpReachNlriIpv6_nexthop_global_set, METH_VARARGS, NULL},
26225  { (char *)"BgpPathAttribMpReachNlriIpv6_nexthop_global_get", _wrap_BgpPathAttribMpReachNlriIpv6_nexthop_global_get, METH_VARARGS, NULL},
26226  { (char *)"BgpPathAttribMpReachNlriIpv6_nexthop_linklocal_set", _wrap_BgpPathAttribMpReachNlriIpv6_nexthop_linklocal_set, METH_VARARGS, NULL},
26227  { (char *)"BgpPathAttribMpReachNlriIpv6_nexthop_linklocal_get", _wrap_BgpPathAttribMpReachNlriIpv6_nexthop_linklocal_get, METH_VARARGS, NULL},
26228  { (char *)"BgpPathAttribMpReachNlriIpv6_nlri_set", _wrap_BgpPathAttribMpReachNlriIpv6_nlri_set, METH_VARARGS, NULL},
26229  { (char *)"BgpPathAttribMpReachNlriIpv6_nlri_get", _wrap_BgpPathAttribMpReachNlriIpv6_nlri_get, METH_VARARGS, NULL},
26230  { (char *)"BgpPathAttribMpReachNlriIpv6_clone", _wrap_BgpPathAttribMpReachNlriIpv6_clone, METH_VARARGS, NULL},
26231  { (char *)"BgpPathAttribMpReachNlriIpv6_parse", _wrap_BgpPathAttribMpReachNlriIpv6_parse, METH_VARARGS, NULL},
26232  { (char *)"BgpPathAttribMpReachNlriIpv6_write", _wrap_BgpPathAttribMpReachNlriIpv6_write, METH_VARARGS, NULL},
26233  { (char *)"BgpPathAttribMpReachNlriIpv6_doPrint", _wrap_BgpPathAttribMpReachNlriIpv6_doPrint, METH_VARARGS, NULL},
26234  { (char *)"BgpPathAttribMpReachNlriIpv6_length", _wrap_BgpPathAttribMpReachNlriIpv6_length, METH_VARARGS, NULL},
26235  { (char *)"delete_BgpPathAttribMpReachNlriIpv6", _wrap_delete_BgpPathAttribMpReachNlriIpv6, METH_VARARGS, NULL},
26236  { (char *)"BgpPathAttribMpReachNlriIpv6_swigregister", BgpPathAttribMpReachNlriIpv6_swigregister, METH_VARARGS, NULL},
26237  { (char *)"new_BgpPathAttribMpReachNlriUnknow", _wrap_new_BgpPathAttribMpReachNlriUnknow, METH_VARARGS, NULL},
26238  { (char *)"delete_BgpPathAttribMpReachNlriUnknow", _wrap_delete_BgpPathAttribMpReachNlriUnknow, METH_VARARGS, NULL},
26239  { (char *)"BgpPathAttribMpReachNlriUnknow_clone", _wrap_BgpPathAttribMpReachNlriUnknow_clone, METH_VARARGS, NULL},
26240  { (char *)"BgpPathAttribMpReachNlriUnknow_parse", _wrap_BgpPathAttribMpReachNlriUnknow_parse, METH_VARARGS, NULL},
26241  { (char *)"BgpPathAttribMpReachNlriUnknow_write", _wrap_BgpPathAttribMpReachNlriUnknow_write, METH_VARARGS, NULL},
26242  { (char *)"BgpPathAttribMpReachNlriUnknow_doPrint", _wrap_BgpPathAttribMpReachNlriUnknow_doPrint, METH_VARARGS, NULL},
26243  { (char *)"BgpPathAttribMpReachNlriUnknow_length", _wrap_BgpPathAttribMpReachNlriUnknow_length, METH_VARARGS, NULL},
26244  { (char *)"BgpPathAttribMpReachNlriUnknow_getNexthop", _wrap_BgpPathAttribMpReachNlriUnknow_getNexthop, METH_VARARGS, NULL},
26245  { (char *)"BgpPathAttribMpReachNlriUnknow_getNlri", _wrap_BgpPathAttribMpReachNlriUnknow_getNlri, METH_VARARGS, NULL},
26246  { (char *)"BgpPathAttribMpReachNlriUnknow_getNexthopLength", _wrap_BgpPathAttribMpReachNlriUnknow_getNexthopLength, METH_VARARGS, NULL},
26247  { (char *)"BgpPathAttribMpReachNlriUnknow_getNlriLength", _wrap_BgpPathAttribMpReachNlriUnknow_getNlriLength, METH_VARARGS, NULL},
26248  { (char *)"BgpPathAttribMpReachNlriUnknow_swigregister", BgpPathAttribMpReachNlriUnknow_swigregister, METH_VARARGS, NULL},
26249  { (char *)"new_BgpPathAttribMpUnreachNlriIpv6", _wrap_new_BgpPathAttribMpUnreachNlriIpv6, METH_VARARGS, NULL},
26250  { (char *)"BgpPathAttribMpUnreachNlriIpv6_withdrawn_routes_set", _wrap_BgpPathAttribMpUnreachNlriIpv6_withdrawn_routes_set, METH_VARARGS, NULL},
26251  { (char *)"BgpPathAttribMpUnreachNlriIpv6_withdrawn_routes_get", _wrap_BgpPathAttribMpUnreachNlriIpv6_withdrawn_routes_get, METH_VARARGS, NULL},
26252  { (char *)"BgpPathAttribMpUnreachNlriIpv6_clone", _wrap_BgpPathAttribMpUnreachNlriIpv6_clone, METH_VARARGS, NULL},
26253  { (char *)"BgpPathAttribMpUnreachNlriIpv6_parse", _wrap_BgpPathAttribMpUnreachNlriIpv6_parse, METH_VARARGS, NULL},
26254  { (char *)"BgpPathAttribMpUnreachNlriIpv6_write", _wrap_BgpPathAttribMpUnreachNlriIpv6_write, METH_VARARGS, NULL},
26255  { (char *)"BgpPathAttribMpUnreachNlriIpv6_doPrint", _wrap_BgpPathAttribMpUnreachNlriIpv6_doPrint, METH_VARARGS, NULL},
26256  { (char *)"BgpPathAttribMpUnreachNlriIpv6_length", _wrap_BgpPathAttribMpUnreachNlriIpv6_length, METH_VARARGS, NULL},
26257  { (char *)"delete_BgpPathAttribMpUnreachNlriIpv6", _wrap_delete_BgpPathAttribMpUnreachNlriIpv6, METH_VARARGS, NULL},
26258  { (char *)"BgpPathAttribMpUnreachNlriIpv6_swigregister", BgpPathAttribMpUnreachNlriIpv6_swigregister, METH_VARARGS, NULL},
26259  { (char *)"new_BgpPathAttribMpUnreachNlriUnknow", _wrap_new_BgpPathAttribMpUnreachNlriUnknow, METH_VARARGS, NULL},
26260  { (char *)"delete_BgpPathAttribMpUnreachNlriUnknow", _wrap_delete_BgpPathAttribMpUnreachNlriUnknow, METH_VARARGS, NULL},
26261  { (char *)"BgpPathAttribMpUnreachNlriUnknow_clone", _wrap_BgpPathAttribMpUnreachNlriUnknow_clone, METH_VARARGS, NULL},
26262  { (char *)"BgpPathAttribMpUnreachNlriUnknow_parse", _wrap_BgpPathAttribMpUnreachNlriUnknow_parse, METH_VARARGS, NULL},
26263  { (char *)"BgpPathAttribMpUnreachNlriUnknow_write", _wrap_BgpPathAttribMpUnreachNlriUnknow_write, METH_VARARGS, NULL},
26264  { (char *)"BgpPathAttribMpUnreachNlriUnknow_doPrint", _wrap_BgpPathAttribMpUnreachNlriUnknow_doPrint, METH_VARARGS, NULL},
26265  { (char *)"BgpPathAttribMpUnreachNlriUnknow_length", _wrap_BgpPathAttribMpUnreachNlriUnknow_length, METH_VARARGS, NULL},
26266  { (char *)"BgpPathAttribMpUnreachNlriUnknow_getWithdrawnRoutes", _wrap_BgpPathAttribMpUnreachNlriUnknow_getWithdrawnRoutes, METH_VARARGS, NULL},
26267  { (char *)"BgpPathAttribMpUnreachNlriUnknow_getWithdrawnRoutesLength", _wrap_BgpPathAttribMpUnreachNlriUnknow_getWithdrawnRoutesLength, METH_VARARGS, NULL},
26268  { (char *)"BgpPathAttribMpUnreachNlriUnknow_swigregister", BgpPathAttribMpUnreachNlriUnknow_swigregister, METH_VARARGS, NULL},
26269  { (char *)"Rib6Entry_src_router_id_set", _wrap_Rib6Entry_src_router_id_set, METH_VARARGS, NULL},
26270  { (char *)"Rib6Entry_src_router_id_get", _wrap_Rib6Entry_src_router_id_get, METH_VARARGS, NULL},
26271  { (char *)"Rib6Entry_update_id_set", _wrap_Rib6Entry_update_id_set, METH_VARARGS, NULL},
26272  { (char *)"Rib6Entry_update_id_get", _wrap_Rib6Entry_update_id_get, METH_VARARGS, NULL},
26273  { (char *)"Rib6Entry_weight_set", _wrap_Rib6Entry_weight_set, METH_VARARGS, NULL},
26274  { (char *)"Rib6Entry_weight_get", _wrap_Rib6Entry_weight_get, METH_VARARGS, NULL},
26275  { (char *)"Rib6Entry_attribs_set", _wrap_Rib6Entry_attribs_set, METH_VARARGS, NULL},
26276  { (char *)"Rib6Entry_attribs_get", _wrap_Rib6Entry_attribs_get, METH_VARARGS, NULL},
26277  { (char *)"Rib6Entry___gt__", _wrap_Rib6Entry___gt__, METH_VARARGS, NULL},
26278  { (char *)"new_Rib6Entry", _wrap_new_Rib6Entry, METH_VARARGS, NULL},
26279  { (char *)"delete_Rib6Entry", _wrap_delete_Rib6Entry, METH_VARARGS, NULL},
26280  { (char *)"Rib6Entry_swigregister", Rib6Entry_swigregister, METH_VARARGS, NULL},
26281  { (char *)"Rib4Entry_src_router_id_set", _wrap_Rib4Entry_src_router_id_set, METH_VARARGS, NULL},
26282  { (char *)"Rib4Entry_src_router_id_get", _wrap_Rib4Entry_src_router_id_get, METH_VARARGS, NULL},
26283  { (char *)"Rib4Entry_update_id_set", _wrap_Rib4Entry_update_id_set, METH_VARARGS, NULL},
26284  { (char *)"Rib4Entry_update_id_get", _wrap_Rib4Entry_update_id_get, METH_VARARGS, NULL},
26285  { (char *)"Rib4Entry_weight_set", _wrap_Rib4Entry_weight_set, METH_VARARGS, NULL},
26286  { (char *)"Rib4Entry_weight_get", _wrap_Rib4Entry_weight_get, METH_VARARGS, NULL},
26287  { (char *)"Rib4Entry_attribs_set", _wrap_Rib4Entry_attribs_set, METH_VARARGS, NULL},
26288  { (char *)"Rib4Entry_attribs_get", _wrap_Rib4Entry_attribs_get, METH_VARARGS, NULL},
26289  { (char *)"Rib4Entry___gt__", _wrap_Rib4Entry___gt__, METH_VARARGS, NULL},
26290  { (char *)"new_Rib4Entry", _wrap_new_Rib4Entry, METH_VARARGS, NULL},
26291  { (char *)"delete_Rib4Entry", _wrap_delete_Rib4Entry, METH_VARARGS, NULL},
26292  { (char *)"Rib4Entry_swigregister", Rib4Entry_swigregister, METH_VARARGS, NULL},
26293  { (char *)"new_BgpRib4Entry", _wrap_new_BgpRib4Entry, METH_VARARGS, NULL},
26294  { (char *)"BgpRib4Entry_route_set", _wrap_BgpRib4Entry_route_set, METH_VARARGS, NULL},
26295  { (char *)"BgpRib4Entry_route_get", _wrap_BgpRib4Entry_route_get, METH_VARARGS, NULL},
26296  { (char *)"BgpRib4Entry_getNexthop", _wrap_BgpRib4Entry_getNexthop, METH_VARARGS, NULL},
26297  { (char *)"delete_BgpRib4Entry", _wrap_delete_BgpRib4Entry, METH_VARARGS, NULL},
26298  { (char *)"BgpRib4Entry_swigregister", BgpRib4Entry_swigregister, METH_VARARGS, NULL},
26299  { (char *)"new_BgpRib4", _wrap_new_BgpRib4, METH_VARARGS, NULL},
26300  { (char *)"BgpRib4_insert", _wrap_BgpRib4_insert, METH_VARARGS, NULL},
26301  { (char *)"BgpRib4_withdraw", _wrap_BgpRib4_withdraw, METH_VARARGS, NULL},
26302  { (char *)"BgpRib4_discard", _wrap_BgpRib4_discard, METH_VARARGS, NULL},
26303  { (char *)"BgpRib4_lookup", _wrap_BgpRib4_lookup, METH_VARARGS, NULL},
26304  { (char *)"BgpRib4_get", _wrap_BgpRib4_get, METH_VARARGS, NULL},
26305  { (char *)"delete_BgpRib4", _wrap_delete_BgpRib4, METH_VARARGS, NULL},
26306  { (char *)"BgpRib4_swigregister", BgpRib4_swigregister, METH_VARARGS, NULL},
26307  { (char *)"new_BgpRib6Entry", _wrap_new_BgpRib6Entry, METH_VARARGS, NULL},
26308  { (char *)"BgpRib6Entry_route_set", _wrap_BgpRib6Entry_route_set, METH_VARARGS, NULL},
26309  { (char *)"BgpRib6Entry_route_get", _wrap_BgpRib6Entry_route_get, METH_VARARGS, NULL},
26310  { (char *)"BgpRib6Entry_nexthop_global_set", _wrap_BgpRib6Entry_nexthop_global_set, METH_VARARGS, NULL},
26311  { (char *)"BgpRib6Entry_nexthop_global_get", _wrap_BgpRib6Entry_nexthop_global_get, METH_VARARGS, NULL},
26312  { (char *)"BgpRib6Entry_nexthop_linklocal_set", _wrap_BgpRib6Entry_nexthop_linklocal_set, METH_VARARGS, NULL},
26313  { (char *)"BgpRib6Entry_nexthop_linklocal_get", _wrap_BgpRib6Entry_nexthop_linklocal_get, METH_VARARGS, NULL},
26314  { (char *)"delete_BgpRib6Entry", _wrap_delete_BgpRib6Entry, METH_VARARGS, NULL},
26315  { (char *)"BgpRib6Entry_swigregister", BgpRib6Entry_swigregister, METH_VARARGS, NULL},
26316  { (char *)"new_BgpRib6", _wrap_new_BgpRib6, METH_VARARGS, NULL},
26317  { (char *)"BgpRib6_insert", _wrap_BgpRib6_insert, METH_VARARGS, NULL},
26318  { (char *)"BgpRib6_withdraw", _wrap_BgpRib6_withdraw, METH_VARARGS, NULL},
26319  { (char *)"BgpRib6_discard", _wrap_BgpRib6_discard, METH_VARARGS, NULL},
26320  { (char *)"BgpRib6_lookup", _wrap_BgpRib6_lookup, METH_VARARGS, NULL},
26321  { (char *)"BgpRib6_get", _wrap_BgpRib6_get, METH_VARARGS, NULL},
26322  { (char *)"delete_BgpRib6", _wrap_delete_BgpRib6, METH_VARARGS, NULL},
26323  { (char *)"BgpRib6_swigregister", BgpRib6_swigregister, METH_VARARGS, NULL},
26324  { (char *)"new_BgpSink", _wrap_new_BgpSink, METH_VARARGS, NULL},
26325  { (char *)"BgpSink_fill", _wrap_BgpSink_fill, METH_VARARGS, NULL},
26326  { (char *)"BgpSink_pour", _wrap_BgpSink_pour, METH_VARARGS, NULL},
26327  { (char *)"BgpSink_getBytesInSink", _wrap_BgpSink_getBytesInSink, METH_VARARGS, NULL},
26328  { (char *)"BgpSink_drain", _wrap_BgpSink_drain, METH_VARARGS, NULL},
26329  { (char *)"BgpSink_setLogger", _wrap_BgpSink_setLogger, METH_VARARGS, NULL},
26330  { (char *)"delete_BgpSink", _wrap_delete_BgpSink, METH_VARARGS, NULL},
26331  { (char *)"BgpSink_swigregister", BgpSink_swigregister, METH_VARARGS, NULL},
26332  { (char *)"BgpUpdateMessage_withdrawn_routes_set", _wrap_BgpUpdateMessage_withdrawn_routes_set, METH_VARARGS, NULL},
26333  { (char *)"BgpUpdateMessage_withdrawn_routes_get", _wrap_BgpUpdateMessage_withdrawn_routes_get, METH_VARARGS, NULL},
26334  { (char *)"BgpUpdateMessage_path_attribute_set", _wrap_BgpUpdateMessage_path_attribute_set, METH_VARARGS, NULL},
26335  { (char *)"BgpUpdateMessage_path_attribute_get", _wrap_BgpUpdateMessage_path_attribute_get, METH_VARARGS, NULL},
26336  { (char *)"BgpUpdateMessage_nlri_set", _wrap_BgpUpdateMessage_nlri_set, METH_VARARGS, NULL},
26337  { (char *)"BgpUpdateMessage_nlri_get", _wrap_BgpUpdateMessage_nlri_get, METH_VARARGS, NULL},
26338  { (char *)"new_BgpUpdateMessage", _wrap_new_BgpUpdateMessage, METH_VARARGS, NULL},
26339  { (char *)"BgpUpdateMessage_getAttrib", _wrap_BgpUpdateMessage_getAttrib, METH_VARARGS, NULL},
26340  { (char *)"BgpUpdateMessage_hasAttrib", _wrap_BgpUpdateMessage_hasAttrib, METH_VARARGS, NULL},
26341  { (char *)"BgpUpdateMessage_addAttrib", _wrap_BgpUpdateMessage_addAttrib, METH_VARARGS, NULL},
26342  { (char *)"BgpUpdateMessage_setAttribs", _wrap_BgpUpdateMessage_setAttribs, METH_VARARGS, NULL},
26343  { (char *)"BgpUpdateMessage_dropAttrib", _wrap_BgpUpdateMessage_dropAttrib, METH_VARARGS, NULL},
26344  { (char *)"BgpUpdateMessage_updateAttribute", _wrap_BgpUpdateMessage_updateAttribute, METH_VARARGS, NULL},
26345  { (char *)"BgpUpdateMessage_dropNonTransitive", _wrap_BgpUpdateMessage_dropNonTransitive, METH_VARARGS, NULL},
26346  { (char *)"BgpUpdateMessage_setNextHop", _wrap_BgpUpdateMessage_setNextHop, METH_VARARGS, NULL},
26347  { (char *)"BgpUpdateMessage_prepend", _wrap_BgpUpdateMessage_prepend, METH_VARARGS, NULL},
26348  { (char *)"BgpUpdateMessage_restoreAsPath", _wrap_BgpUpdateMessage_restoreAsPath, METH_VARARGS, NULL},
26349  { (char *)"BgpUpdateMessage_downgradeAsPath", _wrap_BgpUpdateMessage_downgradeAsPath, METH_VARARGS, NULL},
26350  { (char *)"BgpUpdateMessage_restoreAggregator", _wrap_BgpUpdateMessage_restoreAggregator, METH_VARARGS, NULL},
26351  { (char *)"BgpUpdateMessage_downgradeAggregator", _wrap_BgpUpdateMessage_downgradeAggregator, METH_VARARGS, NULL},
26352  { (char *)"BgpUpdateMessage_setWithdrawn4", _wrap_BgpUpdateMessage_setWithdrawn4, METH_VARARGS, NULL},
26353  { (char *)"BgpUpdateMessage_addWithdrawn4", _wrap_BgpUpdateMessage_addWithdrawn4, METH_VARARGS, NULL},
26354  { (char *)"BgpUpdateMessage_setNlri4", _wrap_BgpUpdateMessage_setNlri4, METH_VARARGS, NULL},
26355  { (char *)"BgpUpdateMessage_addNlri4", _wrap_BgpUpdateMessage_addNlri4, METH_VARARGS, NULL},
26356  { (char *)"BgpUpdateMessage_setWithdrawn6", _wrap_BgpUpdateMessage_setWithdrawn6, METH_VARARGS, NULL},
26357  { (char *)"BgpUpdateMessage_setNlri6", _wrap_BgpUpdateMessage_setNlri6, METH_VARARGS, NULL},
26358  { (char *)"BgpUpdateMessage_doPrint", _wrap_BgpUpdateMessage_doPrint, METH_VARARGS, NULL},
26359  { (char *)"BgpUpdateMessage_parse", _wrap_BgpUpdateMessage_parse, METH_VARARGS, NULL},
26360  { (char *)"BgpUpdateMessage_write", _wrap_BgpUpdateMessage_write, METH_VARARGS, NULL},
26361  { (char *)"delete_BgpUpdateMessage", _wrap_delete_BgpUpdateMessage, METH_VARARGS, NULL},
26362  { (char *)"BgpUpdateMessage_swigregister", BgpUpdateMessage_swigregister, METH_VARARGS, NULL},
26363  { (char *)"Clock_getTime", _wrap_Clock_getTime, METH_VARARGS, NULL},
26364  { (char *)"delete_Clock", _wrap_delete_Clock, METH_VARARGS, NULL},
26365  { (char *)"Clock_swigregister", Clock_swigregister, METH_VARARGS, NULL},
26366  { (char *)"RealtimeClock_getTime", _wrap_RealtimeClock_getTime, METH_VARARGS, NULL},
26367  { (char *)"new_RealtimeClock", _wrap_new_RealtimeClock, METH_VARARGS, NULL},
26368  { (char *)"delete_RealtimeClock", _wrap_delete_RealtimeClock, METH_VARARGS, NULL},
26369  { (char *)"RealtimeClock_swigregister", RealtimeClock_swigregister, METH_VARARGS, NULL},
26370  { NULL, NULL, 0, NULL }
26371 };
26372 
26373 
26374 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
26375 
26376 static void *_p_libbgp__RealtimeClockTo_p_libbgp__Clock(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26377  return (void *)((libbgp::Clock *) ((libbgp::RealtimeClock *) x));
26378 }
26379 static void *_p_libbgp__BgpPathAttribMpReachNlriUnknowTo_p_libbgp__BgpPathAttribMpNlriBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26381 }
26382 static void *_p_libbgp__BgpPathAttribMpUnreachNlriUnknowTo_p_libbgp__BgpPathAttribMpNlriBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26384 }
26385 static void *_p_libbgp__BgpPathAttribMpReachNlriIpv6To_p_libbgp__BgpPathAttribMpNlriBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26387 }
26388 static void *_p_libbgp__BgpPathAttribMpUnreachNlriIpv6To_p_libbgp__BgpPathAttribMpNlriBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26390 }
26391 static void *_p_libbgp__BgpPathAttribMpUnreachNlriIpv6To_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26393 }
26394 static void *_p_libbgp__BgpPathAttribMpReachNlriIpv6To_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26396 }
26397 static void *_p_libbgp__BgpPathAttribOriginTo_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26398  return (void *)((libbgp::BgpPathAttrib *) ((libbgp::BgpPathAttribOrigin *) x));
26399 }
26400 static void *_p_libbgp__BgpPathAttribAsPathTo_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26401  return (void *)((libbgp::BgpPathAttrib *) ((libbgp::BgpPathAttribAsPath *) x));
26402 }
26403 static void *_p_libbgp__BgpPathAttribCommunityTo_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26404  return (void *)((libbgp::BgpPathAttrib *) ((libbgp::BgpPathAttribCommunity *) x));
26405 }
26406 static void *_p_libbgp__BgpPathAttribLocalPrefTo_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26407  return (void *)((libbgp::BgpPathAttrib *) ((libbgp::BgpPathAttribLocalPref *) x));
26408 }
26409 static void *_p_libbgp__BgpPathAttribMpReachNlriUnknowTo_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26411 }
26412 static void *_p_libbgp__BgpPathAttribMpUnreachNlriUnknowTo_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26414 }
26415 static void *_p_libbgp__BgpPathAttribAs4AggregatorTo_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26416  return (void *)((libbgp::BgpPathAttrib *) ((libbgp::BgpPathAttribAs4Aggregator *) x));
26417 }
26418 static void *_p_libbgp__BgpPathAttribAggregatorTo_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26419  return (void *)((libbgp::BgpPathAttrib *) ((libbgp::BgpPathAttribAggregator *) x));
26420 }
26421 static void *_p_libbgp__BgpPathAttribNexthopTo_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26422  return (void *)((libbgp::BgpPathAttrib *) ((libbgp::BgpPathAttribNexthop *) x));
26423 }
26424 static void *_p_libbgp__BgpPathAttribMedTo_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26425  return (void *)((libbgp::BgpPathAttrib *) ((libbgp::BgpPathAttribMed *) x));
26426 }
26427 static void *_p_libbgp__BgpPathAttribAs4PathTo_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26428  return (void *)((libbgp::BgpPathAttrib *) ((libbgp::BgpPathAttribAs4Path *) x));
26429 }
26430 static void *_p_libbgp__BgpPathAttribAtomicAggregateTo_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26431  return (void *)((libbgp::BgpPathAttrib *) ((libbgp::BgpPathAttribAtomicAggregate *) x));
26432 }
26433 static void *_p_libbgp__BgpPathAttribMpNlriBaseTo_p_libbgp__BgpPathAttrib(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26434  return (void *)((libbgp::BgpPathAttrib *) ((libbgp::BgpPathAttribMpNlriBase *) x));
26435 }
26436 static void *_p_libbgp__BgpFilterRuleRoute6To_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26438 }
26439 static void *_p_libbgp__BgpFilterRuleRoute4To_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26441 }
26442 static void *_p_libbgp__BgpRib6EntryTo_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26444 }
26445 static void *_p_libbgp__BgpRib4EntryTo_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26447 }
26448 static void *_p_libbgp__Route4WithdrawEventTo_p_libbgp__RouteEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26449  return (void *)((libbgp::RouteEvent *) ((libbgp::Route4WithdrawEvent *) x));
26450 }
26451 static void *_p_libbgp__Route6WithdrawEventTo_p_libbgp__RouteEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26452  return (void *)((libbgp::RouteEvent *) ((libbgp::Route6WithdrawEvent *) x));
26453 }
26454 static void *_p_libbgp__RouteCollisionEventTo_p_libbgp__RouteEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26455  return (void *)((libbgp::RouteEvent *) ((libbgp::RouteCollisionEvent *) x));
26456 }
26457 static void *_p_libbgp__Route4AddEventTo_p_libbgp__RouteEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26458  return (void *)((libbgp::RouteEvent *) ((libbgp::Route4AddEvent *) x));
26459 }
26460 static void *_p_libbgp__Route6AddEventTo_p_libbgp__RouteEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26461  return (void *)((libbgp::RouteEvent *) ((libbgp::Route6AddEvent *) x));
26462 }
26463 static void *_p_libbgp__BgpCapabilityMpBgpTo_p_libbgp__BgpCapability(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26464  return (void *)((libbgp::BgpCapability *) ((libbgp::BgpCapabilityMpBgp *) x));
26465 }
26466 static void *_p_libbgp__BgpCapabilityUnknowTo_p_libbgp__BgpCapability(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26467  return (void *)((libbgp::BgpCapability *) ((libbgp::BgpCapabilityUnknow *) x));
26468 }
26469 static void *_p_libbgp__BgpCapability4BytesAsnTo_p_libbgp__BgpCapability(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26470  return (void *)((libbgp::BgpCapability *) ((libbgp::BgpCapability4BytesAsn *) x));
26471 }
26472 static void *_p_libbgp__FdOutHandlerTo_p_libbgp__BgpOutHandler(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26473  return (void *)((libbgp::BgpOutHandler *) ((libbgp::FdOutHandler *) x));
26474 }
26475 static void *_p_libbgp__BgpFsmTo_p_libbgp__RouteEventReceiver(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26476  return (void *)((libbgp::RouteEventReceiver *) ((libbgp::BgpFsm *) x));
26477 }
26478 static void *_p_libbgp__Prefix4To_p_libbgp__Prefix(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26479  return (void *)((libbgp::Prefix *) ((libbgp::Prefix4 *) x));
26480 }
26481 static void *_p_libbgp__Prefix6To_p_libbgp__Prefix(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26482  return (void *)((libbgp::Prefix *) ((libbgp::Prefix6 *) x));
26483 }
26484 static void *_p_libbgp__BgpPathAttribOriginTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26486 }
26487 static void *_p_libbgp__BgpPathAttribAsPathTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26489 }
26490 static void *_p_libbgp__BgpPathAttribMpReachNlriIpv6To_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26492 }
26493 static void *_p_libbgp__BgpPathAttribMpUnreachNlriIpv6To_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26495 }
26496 static void *_p_libbgp__BgpPathAttribLocalPrefTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26498 }
26499 static void *_p_libbgp__BgpPathAttribCommunityTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26501 }
26502 static void *_p_libbgp__BgpCapabilityUnknowTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26504 }
26505 static void *_p_libbgp__BgpPathAttribMpReachNlriUnknowTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26507 }
26508 static void *_p_libbgp__BgpPathAttribMpUnreachNlriUnknowTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26510 }
26511 static void *_p_libbgp__BgpOpenMessageTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26512  return (void *)((libbgp::Serializable *) (libbgp::BgpMessage *) ((libbgp::BgpOpenMessage *) x));
26513 }
26514 static void *_p_libbgp__BgpNotificationMessageTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26516 }
26517 static void *_p_libbgp__BgpKeepaliveMessageTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26518  return (void *)((libbgp::Serializable *) (libbgp::BgpMessage *) ((libbgp::BgpKeepaliveMessage *) x));
26519 }
26520 static void *_p_libbgp__BgpBadMessageTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26521  return (void *)((libbgp::Serializable *) (libbgp::BgpMessage *) ((libbgp::BgpBadMessage *) x));
26522 }
26523 static void *_p_libbgp__BgpMessageTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26524  return (void *)((libbgp::Serializable *) ((libbgp::BgpMessage *) x));
26525 }
26526 static void *_p_libbgp__BgpUpdateMessageTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26527  return (void *)((libbgp::Serializable *) (libbgp::BgpMessage *) ((libbgp::BgpUpdateMessage *) x));
26528 }
26529 static void *_p_libbgp__BgpCapabilityTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26530  return (void *)((libbgp::Serializable *) ((libbgp::BgpCapability *) x));
26531 }
26532 static void *_p_libbgp__BgpCapabilityMpBgpTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26534 }
26535 static void *_p_libbgp__BgpCapability4BytesAsnTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26537 }
26538 static void *_p_libbgp__BgpPathAttribAggregatorTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26540 }
26541 static void *_p_libbgp__BgpPathAttribAs4AggregatorTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26543 }
26544 static void *_p_libbgp__BgpPathAttribNexthopTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26546 }
26547 static void *_p_libbgp__BgpPacketTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26548  return (void *)((libbgp::Serializable *) ((libbgp::BgpPacket *) x));
26549 }
26550 static void *_p_libbgp__BgpPathAttribMedTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26551  return (void *)((libbgp::Serializable *) (libbgp::BgpPathAttrib *) ((libbgp::BgpPathAttribMed *) x));
26552 }
26553 static void *_p_libbgp__BgpPathAttribAtomicAggregateTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26555 }
26556 static void *_p_libbgp__BgpPathAttribAs4PathTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26558 }
26559 static void *_p_libbgp__BgpPathAttribMpNlriBaseTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26561 }
26562 static void *_p_libbgp__BgpPathAttribTo_p_libbgp__Serializable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26563  return (void *)((libbgp::Serializable *) ((libbgp::BgpPathAttrib *) x));
26564 }
26565 static void *_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_tTo_p_libbgp__BgpFilterRule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26567 }
26568 static void *_p_libbgp__BgpFilterRuleRoute6To_p_libbgp__BgpFilterRule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26570 }
26571 static void *_p_libbgp__BgpFilterRuleAsPathTo_p_libbgp__BgpFilterRule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26572  return (void *)((libbgp::BgpFilterRule *) ((libbgp::BgpFilterRuleAsPath *) x));
26573 }
26574 static void *_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_tTo_p_libbgp__BgpFilterRule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26576 }
26577 static void *_p_libbgp__BgpFilterRuleRoute4To_p_libbgp__BgpFilterRule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26579 }
26580 static void *_p_libbgp__BgpFilterRuleCommunityTo_p_libbgp__BgpFilterRule(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26581  return (void *)((libbgp::BgpFilterRule *) ((libbgp::BgpFilterRuleCommunity *) x));
26582 }
26583 static void *_p_libbgp__BgpBadMessageTo_p_libbgp__BgpMessage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26584  return (void *)((libbgp::BgpMessage *) ((libbgp::BgpBadMessage *) x));
26585 }
26586 static void *_p_libbgp__BgpKeepaliveMessageTo_p_libbgp__BgpMessage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26587  return (void *)((libbgp::BgpMessage *) ((libbgp::BgpKeepaliveMessage *) x));
26588 }
26589 static void *_p_libbgp__BgpNotificationMessageTo_p_libbgp__BgpMessage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26590  return (void *)((libbgp::BgpMessage *) ((libbgp::BgpNotificationMessage *) x));
26591 }
26592 static void *_p_libbgp__BgpOpenMessageTo_p_libbgp__BgpMessage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26593  return (void *)((libbgp::BgpMessage *) ((libbgp::BgpOpenMessage *) x));
26594 }
26595 static void *_p_libbgp__BgpUpdateMessageTo_p_libbgp__BgpMessage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26596  return (void *)((libbgp::BgpMessage *) ((libbgp::BgpUpdateMessage *) x));
26597 }
26598 static swig_type_info _swigt__p_Afi = {"_p_Afi", "Afi *", 0, 0, (void*)0, 0};
26599 static swig_type_info _swigt__p_BgpOutHandler = {"_p_BgpOutHandler", "BgpOutHandler *", 0, 0, (void*)0, 0};
26600 static swig_type_info _swigt__p_BgpRib4 = {"_p_BgpRib4", "BgpRib4 *", 0, 0, (void*)0, 0};
26601 static swig_type_info _swigt__p_BgpRib6 = {"_p_BgpRib6", "BgpRib6 *", 0, 0, (void*)0, 0};
26602 static swig_type_info _swigt__p_Clock = {"_p_Clock", "Clock *", 0, 0, (void*)0, 0};
26603 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
26604 static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|int32_t *|int_fast16_t *", 0, 0, (void*)0, 0};
26605 static swig_type_info _swigt__p_libbgp__BgpAsPathSegment = {"_p_libbgp__BgpAsPathSegment", "libbgp::BgpAsPathSegment *", 0, 0, (void*)0, 0};
26606 static swig_type_info _swigt__p_libbgp__BgpBadMessage = {"_p_libbgp__BgpBadMessage", "libbgp::BgpBadMessage *", 0, 0, (void*)0, 0};
26607 static swig_type_info _swigt__p_libbgp__BgpCapability = {"_p_libbgp__BgpCapability", "libbgp::BgpCapability *", 0, 0, (void*)0, 0};
26608 static swig_type_info _swigt__p_libbgp__BgpCapability4BytesAsn = {"_p_libbgp__BgpCapability4BytesAsn", "libbgp::BgpCapability4BytesAsn *", 0, 0, (void*)0, 0};
26609 static swig_type_info _swigt__p_libbgp__BgpCapabilityMpBgp = {"_p_libbgp__BgpCapabilityMpBgp", "libbgp::BgpCapabilityMpBgp *", 0, 0, (void*)0, 0};
26610 static swig_type_info _swigt__p_libbgp__BgpCapabilityUnknow = {"_p_libbgp__BgpCapabilityUnknow", "libbgp::BgpCapabilityUnknow *", 0, 0, (void*)0, 0};
26611 static swig_type_info _swigt__p_libbgp__BgpConfig = {"_p_libbgp__BgpConfig", "libbgp::BgpConfig *", 0, 0, (void*)0, 0};
26612 static swig_type_info _swigt__p_libbgp__BgpFilterRule = {"_p_libbgp__BgpFilterRule", "libbgp::BgpFilterRule *", 0, 0, (void*)0, 0};
26613 static swig_type_info _swigt__p_libbgp__BgpFilterRuleAsPath = {"_p_libbgp__BgpFilterRuleAsPath", "libbgp::BgpFilterRuleAsPath *", 0, 0, (void*)0, 0};
26614 static swig_type_info _swigt__p_libbgp__BgpFilterRuleCommunity = {"_p_libbgp__BgpFilterRuleCommunity", "libbgp::BgpFilterRuleCommunity *", 0, 0, (void*)0, 0};
26615 static swig_type_info _swigt__p_libbgp__BgpFilterRuleRoute4 = {"_p_libbgp__BgpFilterRuleRoute4", "libbgp::BgpFilterRuleRoute4 *", 0, 0, (void*)0, 0};
26616 static swig_type_info _swigt__p_libbgp__BgpFilterRuleRoute6 = {"_p_libbgp__BgpFilterRuleRoute6", "libbgp::BgpFilterRuleRoute6 *", 0, 0, (void*)0, 0};
26617 static swig_type_info _swigt__p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t = {"_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t", "libbgp::BgpFilterRuleRoute< libbgp::Prefix4 > *", 0, 0, (void*)0, 0};
26618 static swig_type_info _swigt__p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t = {"_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t", "libbgp::BgpFilterRuleRoute< libbgp::Prefix6 > *", 0, 0, (void*)0, 0};
26619 static swig_type_info _swigt__p_libbgp__BgpFilterRules = {"_p_libbgp__BgpFilterRules", "libbgp::BgpFilterRules *", 0, 0, (void*)0, 0};
26620 static swig_type_info _swigt__p_libbgp__BgpFsm = {"_p_libbgp__BgpFsm", "libbgp::BgpFsm *", 0, 0, (void*)0, 0};
26621 static swig_type_info _swigt__p_libbgp__BgpKeepaliveMessage = {"_p_libbgp__BgpKeepaliveMessage", "libbgp::BgpKeepaliveMessage *", 0, 0, (void*)0, 0};
26622 static swig_type_info _swigt__p_libbgp__BgpLogHandler = {"_p_libbgp__BgpLogHandler", "libbgp::BgpLogHandler *", 0, 0, (void*)0, 0};
26623 static swig_type_info _swigt__p_libbgp__BgpMessage = {"_p_libbgp__BgpMessage", "libbgp::BgpMessage *", 0, 0, (void*)0, 0};
26624 static swig_type_info _swigt__p_libbgp__BgpNotificationMessage = {"_p_libbgp__BgpNotificationMessage", "libbgp::BgpNotificationMessage *", 0, 0, (void*)0, 0};
26625 static swig_type_info _swigt__p_libbgp__BgpOpenMessage = {"_p_libbgp__BgpOpenMessage", "libbgp::BgpOpenMessage *", 0, 0, (void*)0, 0};
26626 static swig_type_info _swigt__p_libbgp__BgpOutHandler = {"_p_libbgp__BgpOutHandler", "libbgp::BgpOutHandler *", 0, 0, (void*)0, 0};
26627 static swig_type_info _swigt__p_libbgp__BgpPacket = {"_p_libbgp__BgpPacket", "libbgp::BgpPacket *", 0, 0, (void*)0, 0};
26628 static swig_type_info _swigt__p_libbgp__BgpPathAttrib = {"_p_libbgp__BgpPathAttrib", "libbgp::BgpPathAttrib *", 0, 0, (void*)0, 0};
26629 static swig_type_info _swigt__p_libbgp__BgpPathAttribAggregator = {"_p_libbgp__BgpPathAttribAggregator", "libbgp::BgpPathAttribAggregator *", 0, 0, (void*)0, 0};
26630 static swig_type_info _swigt__p_libbgp__BgpPathAttribAs4Aggregator = {"_p_libbgp__BgpPathAttribAs4Aggregator", "libbgp::BgpPathAttribAs4Aggregator *", 0, 0, (void*)0, 0};
26631 static swig_type_info _swigt__p_libbgp__BgpPathAttribAs4Path = {"_p_libbgp__BgpPathAttribAs4Path", "libbgp::BgpPathAttribAs4Path *", 0, 0, (void*)0, 0};
26632 static swig_type_info _swigt__p_libbgp__BgpPathAttribAsPath = {"_p_libbgp__BgpPathAttribAsPath", "libbgp::BgpPathAttribAsPath *", 0, 0, (void*)0, 0};
26633 static swig_type_info _swigt__p_libbgp__BgpPathAttribAtomicAggregate = {"_p_libbgp__BgpPathAttribAtomicAggregate", "libbgp::BgpPathAttribAtomicAggregate *", 0, 0, (void*)0, 0};
26634 static swig_type_info _swigt__p_libbgp__BgpPathAttribCommunity = {"_p_libbgp__BgpPathAttribCommunity", "libbgp::BgpPathAttribCommunity *", 0, 0, (void*)0, 0};
26635 static swig_type_info _swigt__p_libbgp__BgpPathAttribLocalPref = {"_p_libbgp__BgpPathAttribLocalPref", "libbgp::BgpPathAttribLocalPref *", 0, 0, (void*)0, 0};
26636 static swig_type_info _swigt__p_libbgp__BgpPathAttribMed = {"_p_libbgp__BgpPathAttribMed", "libbgp::BgpPathAttribMed *", 0, 0, (void*)0, 0};
26637 static swig_type_info _swigt__p_libbgp__BgpPathAttribMpNlriBase = {"_p_libbgp__BgpPathAttribMpNlriBase", "libbgp::BgpPathAttribMpNlriBase *", 0, 0, (void*)0, 0};
26638 static swig_type_info _swigt__p_libbgp__BgpPathAttribMpReachNlriIpv6 = {"_p_libbgp__BgpPathAttribMpReachNlriIpv6", "libbgp::BgpPathAttribMpReachNlriIpv6 *", 0, 0, (void*)0, 0};
26639 static swig_type_info _swigt__p_libbgp__BgpPathAttribMpReachNlriUnknow = {"_p_libbgp__BgpPathAttribMpReachNlriUnknow", "libbgp::BgpPathAttribMpReachNlriUnknow *", 0, 0, (void*)0, 0};
26640 static swig_type_info _swigt__p_libbgp__BgpPathAttribMpUnreachNlriIpv6 = {"_p_libbgp__BgpPathAttribMpUnreachNlriIpv6", "libbgp::BgpPathAttribMpUnreachNlriIpv6 *", 0, 0, (void*)0, 0};
26641 static swig_type_info _swigt__p_libbgp__BgpPathAttribMpUnreachNlriUnknow = {"_p_libbgp__BgpPathAttribMpUnreachNlriUnknow", "libbgp::BgpPathAttribMpUnreachNlriUnknow *", 0, 0, (void*)0, 0};
26642 static swig_type_info _swigt__p_libbgp__BgpPathAttribNexthop = {"_p_libbgp__BgpPathAttribNexthop", "libbgp::BgpPathAttribNexthop *", 0, 0, (void*)0, 0};
26643 static swig_type_info _swigt__p_libbgp__BgpPathAttribOrigin = {"_p_libbgp__BgpPathAttribOrigin", "libbgp::BgpPathAttribOrigin *", 0, 0, (void*)0, 0};
26644 static swig_type_info _swigt__p_libbgp__BgpRib4 = {"_p_libbgp__BgpRib4", "libbgp::BgpRib4 *", 0, 0, (void*)0, 0};
26645 static swig_type_info _swigt__p_libbgp__BgpRib4Entry = {"_p_libbgp__BgpRib4Entry", "libbgp::BgpRib4Entry *", 0, 0, (void*)0, 0};
26646 static swig_type_info _swigt__p_libbgp__BgpRib6 = {"_p_libbgp__BgpRib6", "libbgp::BgpRib6 *", 0, 0, (void*)0, 0};
26647 static swig_type_info _swigt__p_libbgp__BgpRib6Entry = {"_p_libbgp__BgpRib6Entry", "libbgp::BgpRib6Entry *", 0, 0, (void*)0, 0};
26648 static swig_type_info _swigt__p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t = {"_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t", "libbgp::BgpRibEntry< libbgp::BgpRib4Entry > *", 0, 0, (void*)0, 0};
26649 static swig_type_info _swigt__p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t = {"_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t", "libbgp::BgpRibEntry< libbgp::BgpRib6Entry > *", 0, 0, (void*)0, 0};
26650 static swig_type_info _swigt__p_libbgp__BgpSink = {"_p_libbgp__BgpSink", "libbgp::BgpSink *", 0, 0, (void*)0, 0};
26651 static swig_type_info _swigt__p_libbgp__BgpUpdateMessage = {"_p_libbgp__BgpUpdateMessage", "libbgp::BgpUpdateMessage *", 0, 0, (void*)0, 0};
26652 static swig_type_info _swigt__p_libbgp__Clock = {"_p_libbgp__Clock", "libbgp::Clock *", 0, 0, (void*)0, 0};
26653 static swig_type_info _swigt__p_libbgp__FdOutHandler = {"_p_libbgp__FdOutHandler", "libbgp::FdOutHandler *", 0, 0, (void*)0, 0};
26654 static swig_type_info _swigt__p_libbgp__Prefix = {"_p_libbgp__Prefix", "libbgp::Prefix *", 0, 0, (void*)0, 0};
26655 static swig_type_info _swigt__p_libbgp__Prefix4 = {"_p_libbgp__Prefix4", "libbgp::Prefix4 *", 0, 0, (void*)0, 0};
26656 static swig_type_info _swigt__p_libbgp__Prefix6 = {"_p_libbgp__Prefix6", "libbgp::Prefix6 *", 0, 0, (void*)0, 0};
26657 static swig_type_info _swigt__p_libbgp__RealtimeClock = {"_p_libbgp__RealtimeClock", "libbgp::RealtimeClock *", 0, 0, (void*)0, 0};
26658 static swig_type_info _swigt__p_libbgp__Route4AddEvent = {"_p_libbgp__Route4AddEvent", "libbgp::Route4AddEvent *", 0, 0, (void*)0, 0};
26659 static swig_type_info _swigt__p_libbgp__Route4WithdrawEvent = {"_p_libbgp__Route4WithdrawEvent", "libbgp::Route4WithdrawEvent *", 0, 0, (void*)0, 0};
26660 static swig_type_info _swigt__p_libbgp__Route6AddEvent = {"_p_libbgp__Route6AddEvent", "libbgp::Route6AddEvent *", 0, 0, (void*)0, 0};
26661 static swig_type_info _swigt__p_libbgp__Route6WithdrawEvent = {"_p_libbgp__Route6WithdrawEvent", "libbgp::Route6WithdrawEvent *", 0, 0, (void*)0, 0};
26662 static swig_type_info _swigt__p_libbgp__RouteCollisionEvent = {"_p_libbgp__RouteCollisionEvent", "libbgp::RouteCollisionEvent *", 0, 0, (void*)0, 0};
26663 static swig_type_info _swigt__p_libbgp__RouteEvent = {"_p_libbgp__RouteEvent", "libbgp::RouteEvent *", 0, 0, (void*)0, 0};
26664 static swig_type_info _swigt__p_libbgp__RouteEventBus = {"_p_libbgp__RouteEventBus", "libbgp::RouteEventBus *", 0, 0, (void*)0, 0};
26665 static swig_type_info _swigt__p_libbgp__RouteEventReceiver = {"_p_libbgp__RouteEventReceiver", "libbgp::RouteEventReceiver *", 0, 0, (void*)0, 0};
26666 static swig_type_info _swigt__p_libbgp__Serializable = {"_p_libbgp__Serializable", "libbgp::Serializable *", 0, 0, (void*)0, 0};
26667 static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 0, 0, (void*)0, 0};
26668 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
26669 static swig_type_info _swigt__p_p_libbgp__BgpPacket = {"_p_p_libbgp__BgpPacket", "libbgp::BgpPacket **", 0, 0, (void*)0, 0};
26670 static swig_type_info _swigt__p_p_unsigned_char = {"_p_p_unsigned_char", "uint8_t **|unsigned char **", 0, 0, (void*)0, 0};
26671 static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
26672 static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
26673 static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
26674 static swig_type_info _swigt__p_ssize_t = {"_p_ssize_t", "ssize_t *", 0, 0, (void*)0, 0};
26675 static swig_type_info _swigt__p_std__shared_ptrT_libbgp__BgpCapability_t = {"_p_std__shared_ptrT_libbgp__BgpCapability_t", "std::shared_ptr< libbgp::BgpCapability > *", 0, 0, (void*)0, 0};
26676 static swig_type_info _swigt__p_std__vectorT_Prefix4_t = {"_p_std__vectorT_Prefix4_t", "std::vector< Prefix4 > *", 0, 0, (void*)0, 0};
26677 static swig_type_info _swigt__p_std__vectorT_Prefix6_t = {"_p_std__vectorT_Prefix6_t", "std::vector< Prefix6 > *", 0, 0, (void*)0, 0};
26678 static swig_type_info _swigt__p_std__vectorT_libbgp__BgpAsPathSegment_t = {"_p_std__vectorT_libbgp__BgpAsPathSegment_t", "std::vector< libbgp::BgpAsPathSegment > *", 0, 0, (void*)0, 0};
26679 static swig_type_info _swigt__p_std__vectorT_libbgp__BgpRib4Entry_t = {"_p_std__vectorT_libbgp__BgpRib4Entry_t", "std::vector< libbgp::BgpRib4Entry > *", 0, 0, (void*)0, 0};
26680 static swig_type_info _swigt__p_std__vectorT_libbgp__BgpRib6Entry_t = {"_p_std__vectorT_libbgp__BgpRib6Entry_t", "std::vector< libbgp::BgpRib6Entry > *", 0, 0, (void*)0, 0};
26681 static swig_type_info _swigt__p_std__vectorT_libbgp__Prefix4_t = {"_p_std__vectorT_libbgp__Prefix4_t", "std::vector< libbgp::Prefix4 > *", 0, 0, (void*)0, 0};
26682 static swig_type_info _swigt__p_std__vectorT_libbgp__Prefix6_t = {"_p_std__vectorT_libbgp__Prefix6_t", "std::vector< libbgp::Prefix6 > *", 0, 0, (void*)0, 0};
26683 static swig_type_info _swigt__p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t = {"_p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t", "std::vector< std::shared_ptr< BgpPathAttrib > > *", 0, 0, (void*)0, 0};
26684 static swig_type_info _swigt__p_std__vectorT_std__shared_ptrT_libbgp__BgpCapability_t_t = {"_p_std__vectorT_std__shared_ptrT_libbgp__BgpCapability_t_t", "std::vector< std::shared_ptr< libbgp::BgpCapability > > *", 0, 0, (void*)0, 0};
26685 static swig_type_info _swigt__p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t = {"_p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t", "std::vector< std::shared_ptr< libbgp::BgpPathAttrib > > *", 0, 0, (void*)0, 0};
26686 static swig_type_info _swigt__p_std__vectorT_unsigned_int_t = {"_p_std__vectorT_unsigned_int_t", "std::vector< uint32_t > *|std::vector< unsigned int > *", 0, 0, (void*)0, 0};
26687 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
26688 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|unsigned int *|uint_fast16_t *", 0, 0, (void*)0, 0};
26689 static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0};
26690 static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
26691 
26692 static swig_type_info *swig_type_initial[] = {
26693  &_swigt__p_Afi,
26694  &_swigt__p_BgpOutHandler,
26695  &_swigt__p_BgpRib4,
26696  &_swigt__p_BgpRib6,
26697  &_swigt__p_Clock,
26698  &_swigt__p_char,
26699  &_swigt__p_int,
26700  &_swigt__p_libbgp__BgpAsPathSegment,
26701  &_swigt__p_libbgp__BgpBadMessage,
26702  &_swigt__p_libbgp__BgpCapability,
26703  &_swigt__p_libbgp__BgpCapability4BytesAsn,
26704  &_swigt__p_libbgp__BgpCapabilityMpBgp,
26705  &_swigt__p_libbgp__BgpCapabilityUnknow,
26706  &_swigt__p_libbgp__BgpConfig,
26707  &_swigt__p_libbgp__BgpFilterRule,
26708  &_swigt__p_libbgp__BgpFilterRuleAsPath,
26709  &_swigt__p_libbgp__BgpFilterRuleCommunity,
26710  &_swigt__p_libbgp__BgpFilterRuleRoute4,
26711  &_swigt__p_libbgp__BgpFilterRuleRoute6,
26712  &_swigt__p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t,
26713  &_swigt__p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t,
26714  &_swigt__p_libbgp__BgpFilterRules,
26715  &_swigt__p_libbgp__BgpFsm,
26716  &_swigt__p_libbgp__BgpKeepaliveMessage,
26717  &_swigt__p_libbgp__BgpLogHandler,
26718  &_swigt__p_libbgp__BgpMessage,
26719  &_swigt__p_libbgp__BgpNotificationMessage,
26720  &_swigt__p_libbgp__BgpOpenMessage,
26721  &_swigt__p_libbgp__BgpOutHandler,
26722  &_swigt__p_libbgp__BgpPacket,
26723  &_swigt__p_libbgp__BgpPathAttrib,
26724  &_swigt__p_libbgp__BgpPathAttribAggregator,
26725  &_swigt__p_libbgp__BgpPathAttribAs4Aggregator,
26726  &_swigt__p_libbgp__BgpPathAttribAs4Path,
26727  &_swigt__p_libbgp__BgpPathAttribAsPath,
26728  &_swigt__p_libbgp__BgpPathAttribAtomicAggregate,
26729  &_swigt__p_libbgp__BgpPathAttribCommunity,
26730  &_swigt__p_libbgp__BgpPathAttribLocalPref,
26731  &_swigt__p_libbgp__BgpPathAttribMed,
26732  &_swigt__p_libbgp__BgpPathAttribMpNlriBase,
26733  &_swigt__p_libbgp__BgpPathAttribMpReachNlriIpv6,
26734  &_swigt__p_libbgp__BgpPathAttribMpReachNlriUnknow,
26735  &_swigt__p_libbgp__BgpPathAttribMpUnreachNlriIpv6,
26736  &_swigt__p_libbgp__BgpPathAttribMpUnreachNlriUnknow,
26737  &_swigt__p_libbgp__BgpPathAttribNexthop,
26738  &_swigt__p_libbgp__BgpPathAttribOrigin,
26739  &_swigt__p_libbgp__BgpRib4,
26740  &_swigt__p_libbgp__BgpRib4Entry,
26741  &_swigt__p_libbgp__BgpRib6,
26742  &_swigt__p_libbgp__BgpRib6Entry,
26743  &_swigt__p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t,
26744  &_swigt__p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t,
26745  &_swigt__p_libbgp__BgpSink,
26746  &_swigt__p_libbgp__BgpUpdateMessage,
26747  &_swigt__p_libbgp__Clock,
26748  &_swigt__p_libbgp__FdOutHandler,
26749  &_swigt__p_libbgp__Prefix,
26750  &_swigt__p_libbgp__Prefix4,
26751  &_swigt__p_libbgp__Prefix6,
26752  &_swigt__p_libbgp__RealtimeClock,
26753  &_swigt__p_libbgp__Route4AddEvent,
26754  &_swigt__p_libbgp__Route4WithdrawEvent,
26755  &_swigt__p_libbgp__Route6AddEvent,
26756  &_swigt__p_libbgp__Route6WithdrawEvent,
26757  &_swigt__p_libbgp__RouteCollisionEvent,
26758  &_swigt__p_libbgp__RouteEvent,
26759  &_swigt__p_libbgp__RouteEventBus,
26760  &_swigt__p_libbgp__RouteEventReceiver,
26761  &_swigt__p_libbgp__Serializable,
26762  &_swigt__p_long_long,
26763  &_swigt__p_p_char,
26764  &_swigt__p_p_libbgp__BgpPacket,
26765  &_swigt__p_p_unsigned_char,
26766  &_swigt__p_short,
26767  &_swigt__p_signed_char,
26768  &_swigt__p_size_t,
26769  &_swigt__p_ssize_t,
26770  &_swigt__p_std__shared_ptrT_libbgp__BgpCapability_t,
26771  &_swigt__p_std__vectorT_Prefix4_t,
26772  &_swigt__p_std__vectorT_Prefix6_t,
26773  &_swigt__p_std__vectorT_libbgp__BgpAsPathSegment_t,
26774  &_swigt__p_std__vectorT_libbgp__BgpRib4Entry_t,
26775  &_swigt__p_std__vectorT_libbgp__BgpRib6Entry_t,
26776  &_swigt__p_std__vectorT_libbgp__Prefix4_t,
26777  &_swigt__p_std__vectorT_libbgp__Prefix6_t,
26778  &_swigt__p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t,
26779  &_swigt__p_std__vectorT_std__shared_ptrT_libbgp__BgpCapability_t_t,
26780  &_swigt__p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t,
26781  &_swigt__p_std__vectorT_unsigned_int_t,
26782  &_swigt__p_unsigned_char,
26783  &_swigt__p_unsigned_int,
26784  &_swigt__p_unsigned_long_long,
26785  &_swigt__p_unsigned_short,
26786 };
26787 
26788 static swig_cast_info _swigc__p_Afi[] = { {&_swigt__p_Afi, 0, 0, 0},{0, 0, 0, 0}};
26789 static swig_cast_info _swigc__p_BgpOutHandler[] = { {&_swigt__p_BgpOutHandler, 0, 0, 0},{0, 0, 0, 0}};
26790 static swig_cast_info _swigc__p_BgpRib4[] = { {&_swigt__p_BgpRib4, 0, 0, 0},{0, 0, 0, 0}};
26791 static swig_cast_info _swigc__p_BgpRib6[] = { {&_swigt__p_BgpRib6, 0, 0, 0},{0, 0, 0, 0}};
26792 static swig_cast_info _swigc__p_Clock[] = { {&_swigt__p_Clock, 0, 0, 0},{0, 0, 0, 0}};
26793 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
26794 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
26795 static swig_cast_info _swigc__p_libbgp__BgpAsPathSegment[] = { {&_swigt__p_libbgp__BgpAsPathSegment, 0, 0, 0},{0, 0, 0, 0}};
26796 static swig_cast_info _swigc__p_libbgp__BgpBadMessage[] = { {&_swigt__p_libbgp__BgpBadMessage, 0, 0, 0},{0, 0, 0, 0}};
26797 static swig_cast_info _swigc__p_libbgp__BgpCapability[] = { {&_swigt__p_libbgp__BgpCapabilityMpBgp, _p_libbgp__BgpCapabilityMpBgpTo_p_libbgp__BgpCapability, 0, 0}, {&_swigt__p_libbgp__BgpCapabilityUnknow, _p_libbgp__BgpCapabilityUnknowTo_p_libbgp__BgpCapability, 0, 0}, {&_swigt__p_libbgp__BgpCapability, 0, 0, 0}, {&_swigt__p_libbgp__BgpCapability4BytesAsn, _p_libbgp__BgpCapability4BytesAsnTo_p_libbgp__BgpCapability, 0, 0},{0, 0, 0, 0}};
26798 static swig_cast_info _swigc__p_libbgp__BgpCapability4BytesAsn[] = { {&_swigt__p_libbgp__BgpCapability4BytesAsn, 0, 0, 0},{0, 0, 0, 0}};
26799 static swig_cast_info _swigc__p_libbgp__BgpCapabilityMpBgp[] = { {&_swigt__p_libbgp__BgpCapabilityMpBgp, 0, 0, 0},{0, 0, 0, 0}};
26800 static swig_cast_info _swigc__p_libbgp__BgpCapabilityUnknow[] = { {&_swigt__p_libbgp__BgpCapabilityUnknow, 0, 0, 0},{0, 0, 0, 0}};
26801 static swig_cast_info _swigc__p_libbgp__BgpConfig[] = { {&_swigt__p_libbgp__BgpConfig, 0, 0, 0},{0, 0, 0, 0}};
26802 static swig_cast_info _swigc__p_libbgp__BgpFilterRule[] = { {&_swigt__p_libbgp__BgpFilterRule, 0, 0, 0}, {&_swigt__p_libbgp__BgpFilterRuleRoute6, _p_libbgp__BgpFilterRuleRoute6To_p_libbgp__BgpFilterRule, 0, 0}, {&_swigt__p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t, _p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_tTo_p_libbgp__BgpFilterRule, 0, 0}, {&_swigt__p_libbgp__BgpFilterRuleAsPath, _p_libbgp__BgpFilterRuleAsPathTo_p_libbgp__BgpFilterRule, 0, 0}, {&_swigt__p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t, _p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_tTo_p_libbgp__BgpFilterRule, 0, 0}, {&_swigt__p_libbgp__BgpFilterRuleRoute4, _p_libbgp__BgpFilterRuleRoute4To_p_libbgp__BgpFilterRule, 0, 0}, {&_swigt__p_libbgp__BgpFilterRuleCommunity, _p_libbgp__BgpFilterRuleCommunityTo_p_libbgp__BgpFilterRule, 0, 0},{0, 0, 0, 0}};
26803 static swig_cast_info _swigc__p_libbgp__BgpFilterRuleAsPath[] = { {&_swigt__p_libbgp__BgpFilterRuleAsPath, 0, 0, 0},{0, 0, 0, 0}};
26804 static swig_cast_info _swigc__p_libbgp__BgpFilterRuleCommunity[] = { {&_swigt__p_libbgp__BgpFilterRuleCommunity, 0, 0, 0},{0, 0, 0, 0}};
26805 static swig_cast_info _swigc__p_libbgp__BgpFilterRuleRoute4[] = { {&_swigt__p_libbgp__BgpFilterRuleRoute4, 0, 0, 0},{0, 0, 0, 0}};
26806 static swig_cast_info _swigc__p_libbgp__BgpFilterRuleRoute6[] = { {&_swigt__p_libbgp__BgpFilterRuleRoute6, 0, 0, 0},{0, 0, 0, 0}};
26807 static swig_cast_info _swigc__p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t[] = { {&_swigt__p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t, 0, 0, 0}, {&_swigt__p_libbgp__BgpFilterRuleRoute4, _p_libbgp__BgpFilterRuleRoute4To_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t, 0, 0},{0, 0, 0, 0}};
26808 static swig_cast_info _swigc__p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t[] = { {&_swigt__p_libbgp__BgpFilterRuleRoute6, _p_libbgp__BgpFilterRuleRoute6To_p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t, 0, 0}, {&_swigt__p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t, 0, 0, 0},{0, 0, 0, 0}};
26809 static swig_cast_info _swigc__p_libbgp__BgpFilterRules[] = { {&_swigt__p_libbgp__BgpFilterRules, 0, 0, 0},{0, 0, 0, 0}};
26810 static swig_cast_info _swigc__p_libbgp__BgpFsm[] = { {&_swigt__p_libbgp__BgpFsm, 0, 0, 0},{0, 0, 0, 0}};
26811 static swig_cast_info _swigc__p_libbgp__BgpKeepaliveMessage[] = { {&_swigt__p_libbgp__BgpKeepaliveMessage, 0, 0, 0},{0, 0, 0, 0}};
26812 static swig_cast_info _swigc__p_libbgp__BgpLogHandler[] = { {&_swigt__p_libbgp__BgpLogHandler, 0, 0, 0},{0, 0, 0, 0}};
26813 static swig_cast_info _swigc__p_libbgp__BgpMessage[] = { {&_swigt__p_libbgp__BgpMessage, 0, 0, 0}, {&_swigt__p_libbgp__BgpBadMessage, _p_libbgp__BgpBadMessageTo_p_libbgp__BgpMessage, 0, 0}, {&_swigt__p_libbgp__BgpKeepaliveMessage, _p_libbgp__BgpKeepaliveMessageTo_p_libbgp__BgpMessage, 0, 0}, {&_swigt__p_libbgp__BgpNotificationMessage, _p_libbgp__BgpNotificationMessageTo_p_libbgp__BgpMessage, 0, 0}, {&_swigt__p_libbgp__BgpOpenMessage, _p_libbgp__BgpOpenMessageTo_p_libbgp__BgpMessage, 0, 0}, {&_swigt__p_libbgp__BgpUpdateMessage, _p_libbgp__BgpUpdateMessageTo_p_libbgp__BgpMessage, 0, 0},{0, 0, 0, 0}};
26814 static swig_cast_info _swigc__p_libbgp__BgpNotificationMessage[] = { {&_swigt__p_libbgp__BgpNotificationMessage, 0, 0, 0},{0, 0, 0, 0}};
26815 static swig_cast_info _swigc__p_libbgp__BgpOpenMessage[] = { {&_swigt__p_libbgp__BgpOpenMessage, 0, 0, 0},{0, 0, 0, 0}};
26816 static swig_cast_info _swigc__p_libbgp__BgpOutHandler[] = { {&_swigt__p_libbgp__BgpOutHandler, 0, 0, 0}, {&_swigt__p_libbgp__FdOutHandler, _p_libbgp__FdOutHandlerTo_p_libbgp__BgpOutHandler, 0, 0},{0, 0, 0, 0}};
26817 static swig_cast_info _swigc__p_libbgp__BgpPacket[] = { {&_swigt__p_libbgp__BgpPacket, 0, 0, 0},{0, 0, 0, 0}};
26818 static swig_cast_info _swigc__p_libbgp__BgpPathAttrib[] = { {&_swigt__p_libbgp__BgpPathAttribMpUnreachNlriIpv6, _p_libbgp__BgpPathAttribMpUnreachNlriIpv6To_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribMpReachNlriIpv6, _p_libbgp__BgpPathAttribMpReachNlriIpv6To_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribOrigin, _p_libbgp__BgpPathAttribOriginTo_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribAsPath, _p_libbgp__BgpPathAttribAsPathTo_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribCommunity, _p_libbgp__BgpPathAttribCommunityTo_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribLocalPref, _p_libbgp__BgpPathAttribLocalPrefTo_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribMpReachNlriUnknow, _p_libbgp__BgpPathAttribMpReachNlriUnknowTo_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribMpUnreachNlriUnknow, _p_libbgp__BgpPathAttribMpUnreachNlriUnknowTo_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribAs4Aggregator, _p_libbgp__BgpPathAttribAs4AggregatorTo_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribAggregator, _p_libbgp__BgpPathAttribAggregatorTo_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribNexthop, _p_libbgp__BgpPathAttribNexthopTo_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribMed, _p_libbgp__BgpPathAttribMedTo_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribAs4Path, _p_libbgp__BgpPathAttribAs4PathTo_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribAtomicAggregate, _p_libbgp__BgpPathAttribAtomicAggregateTo_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribMpNlriBase, _p_libbgp__BgpPathAttribMpNlriBaseTo_p_libbgp__BgpPathAttrib, 0, 0}, {&_swigt__p_libbgp__BgpPathAttrib, 0, 0, 0},{0, 0, 0, 0}};
26819 static swig_cast_info _swigc__p_libbgp__BgpPathAttribAggregator[] = { {&_swigt__p_libbgp__BgpPathAttribAggregator, 0, 0, 0},{0, 0, 0, 0}};
26820 static swig_cast_info _swigc__p_libbgp__BgpPathAttribAs4Aggregator[] = { {&_swigt__p_libbgp__BgpPathAttribAs4Aggregator, 0, 0, 0},{0, 0, 0, 0}};
26821 static swig_cast_info _swigc__p_libbgp__BgpPathAttribAs4Path[] = { {&_swigt__p_libbgp__BgpPathAttribAs4Path, 0, 0, 0},{0, 0, 0, 0}};
26822 static swig_cast_info _swigc__p_libbgp__BgpPathAttribAsPath[] = { {&_swigt__p_libbgp__BgpPathAttribAsPath, 0, 0, 0},{0, 0, 0, 0}};
26823 static swig_cast_info _swigc__p_libbgp__BgpPathAttribAtomicAggregate[] = { {&_swigt__p_libbgp__BgpPathAttribAtomicAggregate, 0, 0, 0},{0, 0, 0, 0}};
26824 static swig_cast_info _swigc__p_libbgp__BgpPathAttribCommunity[] = { {&_swigt__p_libbgp__BgpPathAttribCommunity, 0, 0, 0},{0, 0, 0, 0}};
26825 static swig_cast_info _swigc__p_libbgp__BgpPathAttribLocalPref[] = { {&_swigt__p_libbgp__BgpPathAttribLocalPref, 0, 0, 0},{0, 0, 0, 0}};
26826 static swig_cast_info _swigc__p_libbgp__BgpPathAttribMed[] = { {&_swigt__p_libbgp__BgpPathAttribMed, 0, 0, 0},{0, 0, 0, 0}};
26827 static swig_cast_info _swigc__p_libbgp__BgpPathAttribMpNlriBase[] = { {&_swigt__p_libbgp__BgpPathAttribMpReachNlriUnknow, _p_libbgp__BgpPathAttribMpReachNlriUnknowTo_p_libbgp__BgpPathAttribMpNlriBase, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribMpUnreachNlriUnknow, _p_libbgp__BgpPathAttribMpUnreachNlriUnknowTo_p_libbgp__BgpPathAttribMpNlriBase, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribMpNlriBase, 0, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribMpReachNlriIpv6, _p_libbgp__BgpPathAttribMpReachNlriIpv6To_p_libbgp__BgpPathAttribMpNlriBase, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribMpUnreachNlriIpv6, _p_libbgp__BgpPathAttribMpUnreachNlriIpv6To_p_libbgp__BgpPathAttribMpNlriBase, 0, 0},{0, 0, 0, 0}};
26828 static swig_cast_info _swigc__p_libbgp__BgpPathAttribMpReachNlriIpv6[] = { {&_swigt__p_libbgp__BgpPathAttribMpReachNlriIpv6, 0, 0, 0},{0, 0, 0, 0}};
26829 static swig_cast_info _swigc__p_libbgp__BgpPathAttribMpReachNlriUnknow[] = { {&_swigt__p_libbgp__BgpPathAttribMpReachNlriUnknow, 0, 0, 0},{0, 0, 0, 0}};
26830 static swig_cast_info _swigc__p_libbgp__BgpPathAttribMpUnreachNlriIpv6[] = { {&_swigt__p_libbgp__BgpPathAttribMpUnreachNlriIpv6, 0, 0, 0},{0, 0, 0, 0}};
26831 static swig_cast_info _swigc__p_libbgp__BgpPathAttribMpUnreachNlriUnknow[] = { {&_swigt__p_libbgp__BgpPathAttribMpUnreachNlriUnknow, 0, 0, 0},{0, 0, 0, 0}};
26832 static swig_cast_info _swigc__p_libbgp__BgpPathAttribNexthop[] = { {&_swigt__p_libbgp__BgpPathAttribNexthop, 0, 0, 0},{0, 0, 0, 0}};
26833 static swig_cast_info _swigc__p_libbgp__BgpPathAttribOrigin[] = { {&_swigt__p_libbgp__BgpPathAttribOrigin, 0, 0, 0},{0, 0, 0, 0}};
26834 static swig_cast_info _swigc__p_libbgp__BgpRib4[] = { {&_swigt__p_libbgp__BgpRib4, 0, 0, 0},{0, 0, 0, 0}};
26835 static swig_cast_info _swigc__p_libbgp__BgpRib4Entry[] = { {&_swigt__p_libbgp__BgpRib4Entry, 0, 0, 0},{0, 0, 0, 0}};
26836 static swig_cast_info _swigc__p_libbgp__BgpRib6[] = { {&_swigt__p_libbgp__BgpRib6, 0, 0, 0},{0, 0, 0, 0}};
26837 static swig_cast_info _swigc__p_libbgp__BgpRib6Entry[] = { {&_swigt__p_libbgp__BgpRib6Entry, 0, 0, 0},{0, 0, 0, 0}};
26838 static swig_cast_info _swigc__p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t[] = { {&_swigt__p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t, 0, 0, 0}, {&_swigt__p_libbgp__BgpRib4Entry, _p_libbgp__BgpRib4EntryTo_p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t, 0, 0},{0, 0, 0, 0}};
26839 static swig_cast_info _swigc__p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t[] = { {&_swigt__p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t, 0, 0, 0}, {&_swigt__p_libbgp__BgpRib6Entry, _p_libbgp__BgpRib6EntryTo_p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t, 0, 0},{0, 0, 0, 0}};
26840 static swig_cast_info _swigc__p_libbgp__BgpSink[] = { {&_swigt__p_libbgp__BgpSink, 0, 0, 0},{0, 0, 0, 0}};
26841 static swig_cast_info _swigc__p_libbgp__BgpUpdateMessage[] = { {&_swigt__p_libbgp__BgpUpdateMessage, 0, 0, 0},{0, 0, 0, 0}};
26842 static swig_cast_info _swigc__p_libbgp__Clock[] = { {&_swigt__p_libbgp__Clock, 0, 0, 0}, {&_swigt__p_libbgp__RealtimeClock, _p_libbgp__RealtimeClockTo_p_libbgp__Clock, 0, 0},{0, 0, 0, 0}};
26843 static swig_cast_info _swigc__p_libbgp__FdOutHandler[] = { {&_swigt__p_libbgp__FdOutHandler, 0, 0, 0},{0, 0, 0, 0}};
26844 static swig_cast_info _swigc__p_libbgp__Prefix[] = { {&_swigt__p_libbgp__Prefix, 0, 0, 0}, {&_swigt__p_libbgp__Prefix4, _p_libbgp__Prefix4To_p_libbgp__Prefix, 0, 0}, {&_swigt__p_libbgp__Prefix6, _p_libbgp__Prefix6To_p_libbgp__Prefix, 0, 0},{0, 0, 0, 0}};
26845 static swig_cast_info _swigc__p_libbgp__Prefix4[] = { {&_swigt__p_libbgp__Prefix4, 0, 0, 0},{0, 0, 0, 0}};
26846 static swig_cast_info _swigc__p_libbgp__Prefix6[] = { {&_swigt__p_libbgp__Prefix6, 0, 0, 0},{0, 0, 0, 0}};
26847 static swig_cast_info _swigc__p_libbgp__RealtimeClock[] = { {&_swigt__p_libbgp__RealtimeClock, 0, 0, 0},{0, 0, 0, 0}};
26848 static swig_cast_info _swigc__p_libbgp__Route4AddEvent[] = { {&_swigt__p_libbgp__Route4AddEvent, 0, 0, 0},{0, 0, 0, 0}};
26849 static swig_cast_info _swigc__p_libbgp__Route4WithdrawEvent[] = { {&_swigt__p_libbgp__Route4WithdrawEvent, 0, 0, 0},{0, 0, 0, 0}};
26850 static swig_cast_info _swigc__p_libbgp__Route6AddEvent[] = { {&_swigt__p_libbgp__Route6AddEvent, 0, 0, 0},{0, 0, 0, 0}};
26851 static swig_cast_info _swigc__p_libbgp__Route6WithdrawEvent[] = { {&_swigt__p_libbgp__Route6WithdrawEvent, 0, 0, 0},{0, 0, 0, 0}};
26852 static swig_cast_info _swigc__p_libbgp__RouteCollisionEvent[] = { {&_swigt__p_libbgp__RouteCollisionEvent, 0, 0, 0},{0, 0, 0, 0}};
26853 static swig_cast_info _swigc__p_libbgp__RouteEvent[] = { {&_swigt__p_libbgp__RouteEvent, 0, 0, 0}, {&_swigt__p_libbgp__Route4WithdrawEvent, _p_libbgp__Route4WithdrawEventTo_p_libbgp__RouteEvent, 0, 0}, {&_swigt__p_libbgp__Route6WithdrawEvent, _p_libbgp__Route6WithdrawEventTo_p_libbgp__RouteEvent, 0, 0}, {&_swigt__p_libbgp__RouteCollisionEvent, _p_libbgp__RouteCollisionEventTo_p_libbgp__RouteEvent, 0, 0}, {&_swigt__p_libbgp__Route4AddEvent, _p_libbgp__Route4AddEventTo_p_libbgp__RouteEvent, 0, 0}, {&_swigt__p_libbgp__Route6AddEvent, _p_libbgp__Route6AddEventTo_p_libbgp__RouteEvent, 0, 0},{0, 0, 0, 0}};
26854 static swig_cast_info _swigc__p_libbgp__RouteEventBus[] = { {&_swigt__p_libbgp__RouteEventBus, 0, 0, 0},{0, 0, 0, 0}};
26855 static swig_cast_info _swigc__p_libbgp__RouteEventReceiver[] = { {&_swigt__p_libbgp__RouteEventReceiver, 0, 0, 0}, {&_swigt__p_libbgp__BgpFsm, _p_libbgp__BgpFsmTo_p_libbgp__RouteEventReceiver, 0, 0},{0, 0, 0, 0}};
26856 static swig_cast_info _swigc__p_libbgp__Serializable[] = { {&_swigt__p_libbgp__BgpPathAttribMpReachNlriIpv6, _p_libbgp__BgpPathAttribMpReachNlriIpv6To_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribMpUnreachNlriIpv6, _p_libbgp__BgpPathAttribMpUnreachNlriIpv6To_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribOrigin, _p_libbgp__BgpPathAttribOriginTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribAsPath, _p_libbgp__BgpPathAttribAsPathTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribCommunity, _p_libbgp__BgpPathAttribCommunityTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribLocalPref, _p_libbgp__BgpPathAttribLocalPrefTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpCapabilityUnknow, _p_libbgp__BgpCapabilityUnknowTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribMpReachNlriUnknow, _p_libbgp__BgpPathAttribMpReachNlriUnknowTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribMpUnreachNlriUnknow, _p_libbgp__BgpPathAttribMpUnreachNlriUnknowTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__Serializable, 0, 0, 0}, {&_swigt__p_libbgp__BgpOpenMessage, _p_libbgp__BgpOpenMessageTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpNotificationMessage, _p_libbgp__BgpNotificationMessageTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpKeepaliveMessage, _p_libbgp__BgpKeepaliveMessageTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpBadMessage, _p_libbgp__BgpBadMessageTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpMessage, _p_libbgp__BgpMessageTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpUpdateMessage, _p_libbgp__BgpUpdateMessageTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpCapability, _p_libbgp__BgpCapabilityTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpCapabilityMpBgp, _p_libbgp__BgpCapabilityMpBgpTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpCapability4BytesAsn, _p_libbgp__BgpCapability4BytesAsnTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribAggregator, _p_libbgp__BgpPathAttribAggregatorTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribAs4Aggregator, _p_libbgp__BgpPathAttribAs4AggregatorTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribNexthop, _p_libbgp__BgpPathAttribNexthopTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPacket, _p_libbgp__BgpPacketTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribMed, _p_libbgp__BgpPathAttribMedTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribAtomicAggregate, _p_libbgp__BgpPathAttribAtomicAggregateTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribAs4Path, _p_libbgp__BgpPathAttribAs4PathTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttribMpNlriBase, _p_libbgp__BgpPathAttribMpNlriBaseTo_p_libbgp__Serializable, 0, 0}, {&_swigt__p_libbgp__BgpPathAttrib, _p_libbgp__BgpPathAttribTo_p_libbgp__Serializable, 0, 0},{0, 0, 0, 0}};
26857 static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
26858 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
26859 static swig_cast_info _swigc__p_p_libbgp__BgpPacket[] = { {&_swigt__p_p_libbgp__BgpPacket, 0, 0, 0},{0, 0, 0, 0}};
26860 static swig_cast_info _swigc__p_p_unsigned_char[] = { {&_swigt__p_p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
26861 static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
26862 static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
26863 static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
26864 static swig_cast_info _swigc__p_ssize_t[] = { {&_swigt__p_ssize_t, 0, 0, 0},{0, 0, 0, 0}};
26865 static swig_cast_info _swigc__p_std__shared_ptrT_libbgp__BgpCapability_t[] = { {&_swigt__p_std__shared_ptrT_libbgp__BgpCapability_t, 0, 0, 0},{0, 0, 0, 0}};
26866 static swig_cast_info _swigc__p_std__vectorT_Prefix4_t[] = { {&_swigt__p_std__vectorT_Prefix4_t, 0, 0, 0},{0, 0, 0, 0}};
26867 static swig_cast_info _swigc__p_std__vectorT_Prefix6_t[] = { {&_swigt__p_std__vectorT_Prefix6_t, 0, 0, 0},{0, 0, 0, 0}};
26868 static swig_cast_info _swigc__p_std__vectorT_libbgp__BgpAsPathSegment_t[] = { {&_swigt__p_std__vectorT_libbgp__BgpAsPathSegment_t, 0, 0, 0},{0, 0, 0, 0}};
26869 static swig_cast_info _swigc__p_std__vectorT_libbgp__BgpRib4Entry_t[] = { {&_swigt__p_std__vectorT_libbgp__BgpRib4Entry_t, 0, 0, 0},{0, 0, 0, 0}};
26870 static swig_cast_info _swigc__p_std__vectorT_libbgp__BgpRib6Entry_t[] = { {&_swigt__p_std__vectorT_libbgp__BgpRib6Entry_t, 0, 0, 0},{0, 0, 0, 0}};
26871 static swig_cast_info _swigc__p_std__vectorT_libbgp__Prefix4_t[] = { {&_swigt__p_std__vectorT_libbgp__Prefix4_t, 0, 0, 0},{0, 0, 0, 0}};
26872 static swig_cast_info _swigc__p_std__vectorT_libbgp__Prefix6_t[] = { {&_swigt__p_std__vectorT_libbgp__Prefix6_t, 0, 0, 0},{0, 0, 0, 0}};
26873 static swig_cast_info _swigc__p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t[] = { {&_swigt__p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t, 0, 0, 0},{0, 0, 0, 0}};
26874 static swig_cast_info _swigc__p_std__vectorT_std__shared_ptrT_libbgp__BgpCapability_t_t[] = { {&_swigt__p_std__vectorT_std__shared_ptrT_libbgp__BgpCapability_t_t, 0, 0, 0},{0, 0, 0, 0}};
26875 static swig_cast_info _swigc__p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t[] = { {&_swigt__p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t, 0, 0, 0},{0, 0, 0, 0}};
26876 static swig_cast_info _swigc__p_std__vectorT_unsigned_int_t[] = { {&_swigt__p_std__vectorT_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
26877 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
26878 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
26879 static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
26880 static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
26881 
26882 static swig_cast_info *swig_cast_initial[] = {
26883  _swigc__p_Afi,
26884  _swigc__p_BgpOutHandler,
26885  _swigc__p_BgpRib4,
26886  _swigc__p_BgpRib6,
26887  _swigc__p_Clock,
26888  _swigc__p_char,
26889  _swigc__p_int,
26890  _swigc__p_libbgp__BgpAsPathSegment,
26891  _swigc__p_libbgp__BgpBadMessage,
26892  _swigc__p_libbgp__BgpCapability,
26893  _swigc__p_libbgp__BgpCapability4BytesAsn,
26894  _swigc__p_libbgp__BgpCapabilityMpBgp,
26895  _swigc__p_libbgp__BgpCapabilityUnknow,
26896  _swigc__p_libbgp__BgpConfig,
26897  _swigc__p_libbgp__BgpFilterRule,
26898  _swigc__p_libbgp__BgpFilterRuleAsPath,
26899  _swigc__p_libbgp__BgpFilterRuleCommunity,
26900  _swigc__p_libbgp__BgpFilterRuleRoute4,
26901  _swigc__p_libbgp__BgpFilterRuleRoute6,
26902  _swigc__p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix4_t,
26903  _swigc__p_libbgp__BgpFilterRuleRouteT_libbgp__Prefix6_t,
26904  _swigc__p_libbgp__BgpFilterRules,
26905  _swigc__p_libbgp__BgpFsm,
26906  _swigc__p_libbgp__BgpKeepaliveMessage,
26907  _swigc__p_libbgp__BgpLogHandler,
26908  _swigc__p_libbgp__BgpMessage,
26909  _swigc__p_libbgp__BgpNotificationMessage,
26910  _swigc__p_libbgp__BgpOpenMessage,
26911  _swigc__p_libbgp__BgpOutHandler,
26912  _swigc__p_libbgp__BgpPacket,
26913  _swigc__p_libbgp__BgpPathAttrib,
26914  _swigc__p_libbgp__BgpPathAttribAggregator,
26915  _swigc__p_libbgp__BgpPathAttribAs4Aggregator,
26916  _swigc__p_libbgp__BgpPathAttribAs4Path,
26917  _swigc__p_libbgp__BgpPathAttribAsPath,
26918  _swigc__p_libbgp__BgpPathAttribAtomicAggregate,
26919  _swigc__p_libbgp__BgpPathAttribCommunity,
26920  _swigc__p_libbgp__BgpPathAttribLocalPref,
26921  _swigc__p_libbgp__BgpPathAttribMed,
26922  _swigc__p_libbgp__BgpPathAttribMpNlriBase,
26923  _swigc__p_libbgp__BgpPathAttribMpReachNlriIpv6,
26924  _swigc__p_libbgp__BgpPathAttribMpReachNlriUnknow,
26925  _swigc__p_libbgp__BgpPathAttribMpUnreachNlriIpv6,
26926  _swigc__p_libbgp__BgpPathAttribMpUnreachNlriUnknow,
26927  _swigc__p_libbgp__BgpPathAttribNexthop,
26928  _swigc__p_libbgp__BgpPathAttribOrigin,
26929  _swigc__p_libbgp__BgpRib4,
26930  _swigc__p_libbgp__BgpRib4Entry,
26931  _swigc__p_libbgp__BgpRib6,
26932  _swigc__p_libbgp__BgpRib6Entry,
26933  _swigc__p_libbgp__BgpRibEntryT_libbgp__BgpRib4Entry_t,
26934  _swigc__p_libbgp__BgpRibEntryT_libbgp__BgpRib6Entry_t,
26935  _swigc__p_libbgp__BgpSink,
26936  _swigc__p_libbgp__BgpUpdateMessage,
26937  _swigc__p_libbgp__Clock,
26938  _swigc__p_libbgp__FdOutHandler,
26939  _swigc__p_libbgp__Prefix,
26940  _swigc__p_libbgp__Prefix4,
26941  _swigc__p_libbgp__Prefix6,
26942  _swigc__p_libbgp__RealtimeClock,
26943  _swigc__p_libbgp__Route4AddEvent,
26944  _swigc__p_libbgp__Route4WithdrawEvent,
26945  _swigc__p_libbgp__Route6AddEvent,
26946  _swigc__p_libbgp__Route6WithdrawEvent,
26947  _swigc__p_libbgp__RouteCollisionEvent,
26948  _swigc__p_libbgp__RouteEvent,
26949  _swigc__p_libbgp__RouteEventBus,
26950  _swigc__p_libbgp__RouteEventReceiver,
26951  _swigc__p_libbgp__Serializable,
26952  _swigc__p_long_long,
26953  _swigc__p_p_char,
26954  _swigc__p_p_libbgp__BgpPacket,
26955  _swigc__p_p_unsigned_char,
26956  _swigc__p_short,
26957  _swigc__p_signed_char,
26958  _swigc__p_size_t,
26959  _swigc__p_ssize_t,
26960  _swigc__p_std__shared_ptrT_libbgp__BgpCapability_t,
26961  _swigc__p_std__vectorT_Prefix4_t,
26962  _swigc__p_std__vectorT_Prefix6_t,
26963  _swigc__p_std__vectorT_libbgp__BgpAsPathSegment_t,
26964  _swigc__p_std__vectorT_libbgp__BgpRib4Entry_t,
26965  _swigc__p_std__vectorT_libbgp__BgpRib6Entry_t,
26966  _swigc__p_std__vectorT_libbgp__Prefix4_t,
26967  _swigc__p_std__vectorT_libbgp__Prefix6_t,
26968  _swigc__p_std__vectorT_std__shared_ptrT_BgpPathAttrib_t_t,
26969  _swigc__p_std__vectorT_std__shared_ptrT_libbgp__BgpCapability_t_t,
26970  _swigc__p_std__vectorT_std__shared_ptrT_libbgp__BgpPathAttrib_t_t,
26971  _swigc__p_std__vectorT_unsigned_int_t,
26972  _swigc__p_unsigned_char,
26973  _swigc__p_unsigned_int,
26974  _swigc__p_unsigned_long_long,
26975  _swigc__p_unsigned_short,
26976 };
26977 
26978 
26979 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
26980 
26981 static swig_const_info swig_const_table[] = {
26982 {0, 0, 0, 0.0, 0, 0}};
26983 
26984 #ifdef __cplusplus
26985 }
26986 #endif
26987 /* -----------------------------------------------------------------------------
26988  * Type initialization:
26989  * This problem is tough by the requirement that no dynamic
26990  * memory is used. Also, since swig_type_info structures store pointers to
26991  * swig_cast_info structures and swig_cast_info structures store pointers back
26992  * to swig_type_info structures, we need some lookup code at initialization.
26993  * The idea is that swig generates all the structures that are needed.
26994  * The runtime then collects these partially filled structures.
26995  * The SWIG_InitializeModule function takes these initial arrays out of
26996  * swig_module, and does all the lookup, filling in the swig_module.types
26997  * array with the correct data and linking the correct swig_cast_info
26998  * structures together.
26999  *
27000  * The generated swig_type_info structures are assigned statically to an initial
27001  * array. We just loop through that array, and handle each type individually.
27002  * First we lookup if this type has been already loaded, and if so, use the
27003  * loaded structure instead of the generated one. Then we have to fill in the
27004  * cast linked list. The cast data is initially stored in something like a
27005  * two-dimensional array. Each row corresponds to a type (there are the same
27006  * number of rows as there are in the swig_type_initial array). Each entry in
27007  * a column is one of the swig_cast_info structures for that type.
27008  * The cast_initial array is actually an array of arrays, because each row has
27009  * a variable number of columns. So to actually build the cast linked list,
27010  * we find the array of casts associated with the type, and loop through it
27011  * adding the casts to the list. The one last trick we need to do is making
27012  * sure the type pointer in the swig_cast_info struct is correct.
27013  *
27014  * First off, we lookup the cast->type name to see if it is already loaded.
27015  * There are three cases to handle:
27016  * 1) If the cast->type has already been loaded AND the type we are adding
27017  * casting info to has not been loaded (it is in this module), THEN we
27018  * replace the cast->type pointer with the type pointer that has already
27019  * been loaded.
27020  * 2) If BOTH types (the one we are adding casting info to, and the
27021  * cast->type) are loaded, THEN the cast info has already been loaded by
27022  * the previous module so we just ignore it.
27023  * 3) Finally, if cast->type has not already been loaded, then we add that
27024  * swig_cast_info to the linked list (because the cast->type) pointer will
27025  * be correct.
27026  * ----------------------------------------------------------------------------- */
27027 
27028 #ifdef __cplusplus
27029 extern "C" {
27030 #if 0
27031 } /* c-mode */
27032 #endif
27033 #endif
27034 
27035 #if 0
27036 #define SWIGRUNTIME_DEBUG
27037 #endif
27038 
27039 
27040 SWIGRUNTIME void
27041 SWIG_InitializeModule(void *clientdata) {
27042  size_t i;
27043  swig_module_info *module_head, *iter;
27044  int init;
27045 
27046  /* check to see if the circular list has been setup, if not, set it up */
27047  if (swig_module.next==0) {
27048  /* Initialize the swig_module */
27049  swig_module.type_initial = swig_type_initial;
27050  swig_module.cast_initial = swig_cast_initial;
27051  swig_module.next = &swig_module;
27052  init = 1;
27053  } else {
27054  init = 0;
27055  }
27056 
27057  /* Try and load any already created modules */
27058  module_head = SWIG_GetModule(clientdata);
27059  if (!module_head) {
27060  /* This is the first module loaded for this interpreter */
27061  /* so set the swig module into the interpreter */
27062  SWIG_SetModule(clientdata, &swig_module);
27063  } else {
27064  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
27065  iter=module_head;
27066  do {
27067  if (iter==&swig_module) {
27068  /* Our module is already in the list, so there's nothing more to do. */
27069  return;
27070  }
27071  iter=iter->next;
27072  } while (iter!= module_head);
27073 
27074  /* otherwise we must add our module into the list */
27075  swig_module.next = module_head->next;
27076  module_head->next = &swig_module;
27077  }
27078 
27079  /* When multiple interpreters are used, a module could have already been initialized in
27080  a different interpreter, but not yet have a pointer in this interpreter.
27081  In this case, we do not want to continue adding types... everything should be
27082  set up already */
27083  if (init == 0) return;
27084 
27085  /* Now work on filling in swig_module.types */
27086 #ifdef SWIGRUNTIME_DEBUG
27087  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
27088 #endif
27089  for (i = 0; i < swig_module.size; ++i) {
27090  swig_type_info *type = 0;
27091  swig_type_info *ret;
27092  swig_cast_info *cast;
27093 
27094 #ifdef SWIGRUNTIME_DEBUG
27095  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
27096 #endif
27097 
27098  /* if there is another module already loaded */
27099  if (swig_module.next != &swig_module) {
27100  type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
27101  }
27102  if (type) {
27103  /* Overwrite clientdata field */
27104 #ifdef SWIGRUNTIME_DEBUG
27105  printf("SWIG_InitializeModule: found type %s\n", type->name);
27106 #endif
27107  if (swig_module.type_initial[i]->clientdata) {
27108  type->clientdata = swig_module.type_initial[i]->clientdata;
27109 #ifdef SWIGRUNTIME_DEBUG
27110  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27111 #endif
27112  }
27113  } else {
27114  type = swig_module.type_initial[i];
27115  }
27116 
27117  /* Insert casting types */
27118  cast = swig_module.cast_initial[i];
27119  while (cast->type) {
27120  /* Don't need to add information already in the list */
27121  ret = 0;
27122 #ifdef SWIGRUNTIME_DEBUG
27123  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
27124 #endif
27125  if (swig_module.next != &swig_module) {
27126  ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
27127 #ifdef SWIGRUNTIME_DEBUG
27128  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
27129 #endif
27130  }
27131  if (ret) {
27132  if (type == swig_module.type_initial[i]) {
27133 #ifdef SWIGRUNTIME_DEBUG
27134  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
27135 #endif
27136  cast->type = ret;
27137  ret = 0;
27138  } else {
27139  /* Check for casting already in the list */
27140  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
27141 #ifdef SWIGRUNTIME_DEBUG
27142  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
27143 #endif
27144  if (!ocast) ret = 0;
27145  }
27146  }
27147 
27148  if (!ret) {
27149 #ifdef SWIGRUNTIME_DEBUG
27150  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
27151 #endif
27152  if (type->cast) {
27153  type->cast->prev = cast;
27154  cast->next = type->cast;
27155  }
27156  type->cast = cast;
27157  }
27158  cast++;
27159  }
27160  /* Set entry in modules->types array equal to the type */
27161  swig_module.types[i] = type;
27162  }
27163  swig_module.types[i] = 0;
27164 
27165 #ifdef SWIGRUNTIME_DEBUG
27166  printf("**** SWIG_InitializeModule: Cast List ******\n");
27167  for (i = 0; i < swig_module.size; ++i) {
27168  int j = 0;
27169  swig_cast_info *cast = swig_module.cast_initial[i];
27170  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
27171  while (cast->type) {
27172  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
27173  cast++;
27174  ++j;
27175  }
27176  printf("---- Total casts: %d\n",j);
27177  }
27178  printf("**** SWIG_InitializeModule: Cast List ******\n");
27179 #endif
27180 }
27181 
27182 /* This function will propagate the clientdata field of type to
27183 * any new swig_type_info structures that have been added into the list
27184 * of equivalent types. It is like calling
27185 * SWIG_TypeClientData(type, clientdata) a second time.
27186 */
27187 SWIGRUNTIME void
27188 SWIG_PropagateClientData(void) {
27189  size_t i;
27190  swig_cast_info *equiv;
27191  static int init_run = 0;
27192 
27193  if (init_run) return;
27194  init_run = 1;
27195 
27196  for (i = 0; i < swig_module.size; i++) {
27197  if (swig_module.types[i]->clientdata) {
27198  equiv = swig_module.types[i]->cast;
27199  while (equiv) {
27200  if (!equiv->converter) {
27201  if (equiv->type && !equiv->type->clientdata)
27202  SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
27203  }
27204  equiv = equiv->next;
27205  }
27206  }
27207  }
27208 }
27209 
27210 #ifdef __cplusplus
27211 #if 0
27212 {
27213  /* c-mode */
27214 #endif
27215 }
27216 #endif
27217 
27218 
27219 
27220 #ifdef __cplusplus
27221 extern "C" {
27222 #endif
27223 
27224  /* Python-specific SWIG API */
27225 #define SWIG_newvarlink() SWIG_Python_newvarlink()
27226 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
27227 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
27228 
27229  /* -----------------------------------------------------------------------------
27230  * global variable support code.
27231  * ----------------------------------------------------------------------------- */
27232 
27233  typedef struct swig_globalvar {
27234  char *name; /* Name of global variable */
27235  PyObject *(*get_attr)(void); /* Return the current value */
27236  int (*set_attr)(PyObject *); /* Set the value */
27237  struct swig_globalvar *next;
27238  } swig_globalvar;
27239 
27240  typedef struct swig_varlinkobject {
27241  PyObject_HEAD
27242  swig_globalvar *vars;
27244 
27245  SWIGINTERN PyObject *
27246  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
27247 #if PY_VERSION_HEX >= 0x03000000
27248  return PyUnicode_InternFromString("<Swig global variables>");
27249 #else
27250  return PyString_FromString("<Swig global variables>");
27251 #endif
27252  }
27253 
27254  SWIGINTERN PyObject *
27255  swig_varlink_str(swig_varlinkobject *v) {
27256 #if PY_VERSION_HEX >= 0x03000000
27257  PyObject *str = PyUnicode_InternFromString("(");
27258  PyObject *tail;
27259  PyObject *joined;
27260  swig_globalvar *var;
27261  for (var = v->vars; var; var=var->next) {
27262  tail = PyUnicode_FromString(var->name);
27263  joined = PyUnicode_Concat(str, tail);
27264  Py_DecRef(str);
27265  Py_DecRef(tail);
27266  str = joined;
27267  if (var->next) {
27268  tail = PyUnicode_InternFromString(", ");
27269  joined = PyUnicode_Concat(str, tail);
27270  Py_DecRef(str);
27271  Py_DecRef(tail);
27272  str = joined;
27273  }
27274  }
27275  tail = PyUnicode_InternFromString(")");
27276  joined = PyUnicode_Concat(str, tail);
27277  Py_DecRef(str);
27278  Py_DecRef(tail);
27279  str = joined;
27280 #else
27281  PyObject *str = PyString_FromString("(");
27282  swig_globalvar *var;
27283  for (var = v->vars; var; var=var->next) {
27284  PyString_ConcatAndDel(&str,PyString_FromString(var->name));
27285  if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
27286  }
27287  PyString_ConcatAndDel(&str,PyString_FromString(")"));
27288 #endif
27289  return str;
27290  }
27291 
27292  SWIGINTERN int
27293  swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
27294  char *tmp;
27295  PyObject *str = swig_varlink_str(v);
27296  fprintf(fp,"Swig global variables ");
27297  fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
27298  SWIG_Python_str_DelForPy3(tmp);
27299  Py_DECREF(str);
27300  return 0;
27301  }
27302 
27303  SWIGINTERN void
27304  swig_varlink_dealloc(swig_varlinkobject *v) {
27305  swig_globalvar *var = v->vars;
27306  while (var) {
27307  swig_globalvar *n = var->next;
27308  free(var->name);
27309  free(var);
27310  var = n;
27311  }
27312  }
27313 
27314  SWIGINTERN PyObject *
27315  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
27316  PyObject *res = NULL;
27317  swig_globalvar *var = v->vars;
27318  while (var) {
27319  if (strcmp(var->name,n) == 0) {
27320  res = (*var->get_attr)();
27321  break;
27322  }
27323  var = var->next;
27324  }
27325  if (res == NULL && !PyErr_Occurred()) {
27326  PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
27327  }
27328  return res;
27329  }
27330 
27331  SWIGINTERN int
27332  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
27333  int res = 1;
27334  swig_globalvar *var = v->vars;
27335  while (var) {
27336  if (strcmp(var->name,n) == 0) {
27337  res = (*var->set_attr)(p);
27338  break;
27339  }
27340  var = var->next;
27341  }
27342  if (res == 1 && !PyErr_Occurred()) {
27343  PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
27344  }
27345  return res;
27346  }
27347 
27348  SWIGINTERN PyTypeObject*
27349  swig_varlink_type(void) {
27350  static char varlink__doc__[] = "Swig var link object";
27351  static PyTypeObject varlink_type;
27352  static int type_init = 0;
27353  if (!type_init) {
27354  const PyTypeObject tmp = {
27355  /* PyObject header changed in Python 3 */
27356 #if PY_VERSION_HEX >= 0x03000000
27357  PyVarObject_HEAD_INIT(NULL, 0)
27358 #else
27359  PyObject_HEAD_INIT(NULL)
27360  0, /* ob_size */
27361 #endif
27362  (char *)"swigvarlink", /* tp_name */
27363  sizeof(swig_varlinkobject), /* tp_basicsize */
27364  0, /* tp_itemsize */
27365  (destructor) swig_varlink_dealloc, /* tp_dealloc */
27366  (printfunc) swig_varlink_print, /* tp_print */
27367  (getattrfunc) swig_varlink_getattr, /* tp_getattr */
27368  (setattrfunc) swig_varlink_setattr, /* tp_setattr */
27369  0, /* tp_compare */
27370  (reprfunc) swig_varlink_repr, /* tp_repr */
27371  0, /* tp_as_number */
27372  0, /* tp_as_sequence */
27373  0, /* tp_as_mapping */
27374  0, /* tp_hash */
27375  0, /* tp_call */
27376  (reprfunc) swig_varlink_str, /* tp_str */
27377  0, /* tp_getattro */
27378  0, /* tp_setattro */
27379  0, /* tp_as_buffer */
27380  0, /* tp_flags */
27381  varlink__doc__, /* tp_doc */
27382  0, /* tp_traverse */
27383  0, /* tp_clear */
27384  0, /* tp_richcompare */
27385  0, /* tp_weaklistoffset */
27386 #if PY_VERSION_HEX >= 0x02020000
27387  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
27388 #endif
27389 #if PY_VERSION_HEX >= 0x02030000
27390  0, /* tp_del */
27391 #endif
27392 #if PY_VERSION_HEX >= 0x02060000
27393  0, /* tp_version_tag */
27394 #endif
27395 #if PY_VERSION_HEX >= 0x03040000
27396  0, /* tp_finalize */
27397 #endif
27398 #ifdef COUNT_ALLOCS
27399  0, /* tp_allocs */
27400  0, /* tp_frees */
27401  0, /* tp_maxalloc */
27402 #if PY_VERSION_HEX >= 0x02050000
27403  0, /* tp_prev */
27404 #endif
27405  0 /* tp_next */
27406 #endif
27407  };
27408  varlink_type = tmp;
27409  type_init = 1;
27410 #if PY_VERSION_HEX < 0x02020000
27411  varlink_type.ob_type = &PyType_Type;
27412 #else
27413  if (PyType_Ready(&varlink_type) < 0)
27414  return NULL;
27415 #endif
27416  }
27417  return &varlink_type;
27418  }
27419 
27420  /* Create a variable linking object for use later */
27421  SWIGINTERN PyObject *
27422  SWIG_Python_newvarlink(void) {
27423  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
27424  if (result) {
27425  result->vars = 0;
27426  }
27427  return ((PyObject*) result);
27428  }
27429 
27430  SWIGINTERN void
27431  SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
27433  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
27434  if (gv) {
27435  size_t size = strlen(name)+1;
27436  gv->name = (char *)malloc(size);
27437  if (gv->name) {
27438  strncpy(gv->name,name,size);
27439  gv->get_attr = get_attr;
27440  gv->set_attr = set_attr;
27441  gv->next = v->vars;
27442  }
27443  }
27444  v->vars = gv;
27445  }
27446 
27447  SWIGINTERN PyObject *
27448  SWIG_globals(void) {
27449  static PyObject *_SWIG_globals = 0;
27450  if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
27451  return _SWIG_globals;
27452  }
27453 
27454  /* -----------------------------------------------------------------------------
27455  * constants/methods manipulation
27456  * ----------------------------------------------------------------------------- */
27457 
27458  /* Install Constants */
27459  SWIGINTERN void
27460  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
27461  PyObject *obj = 0;
27462  size_t i;
27463  for (i = 0; constants[i].type; ++i) {
27464  switch(constants[i].type) {
27465  case SWIG_PY_POINTER:
27466  obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
27467  break;
27468  case SWIG_PY_BINARY:
27469  obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
27470  break;
27471  default:
27472  obj = 0;
27473  break;
27474  }
27475  if (obj) {
27476  PyDict_SetItemString(d, constants[i].name, obj);
27477  Py_DECREF(obj);
27478  }
27479  }
27480  }
27481 
27482  /* -----------------------------------------------------------------------------*/
27483  /* Fix SwigMethods to carry the callback ptrs when needed */
27484  /* -----------------------------------------------------------------------------*/
27485 
27486  SWIGINTERN void
27487  SWIG_Python_FixMethods(PyMethodDef *methods,
27488  swig_const_info *const_table,
27489  swig_type_info **types,
27490  swig_type_info **types_initial) {
27491  size_t i;
27492  for (i = 0; methods[i].ml_name; ++i) {
27493  const char *c = methods[i].ml_doc;
27494  if (!c) continue;
27495  c = strstr(c, "swig_ptr: ");
27496  if (c) {
27497  int j;
27498  swig_const_info *ci = 0;
27499  const char *name = c + 10;
27500  for (j = 0; const_table[j].type; ++j) {
27501  if (strncmp(const_table[j].name, name,
27502  strlen(const_table[j].name)) == 0) {
27503  ci = &(const_table[j]);
27504  break;
27505  }
27506  }
27507  if (ci) {
27508  void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
27509  if (ptr) {
27510  size_t shift = (ci->ptype) - types;
27511  swig_type_info *ty = types_initial[shift];
27512  size_t ldoc = (c - methods[i].ml_doc);
27513  size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
27514  char *ndoc = (char*)malloc(ldoc + lptr + 10);
27515  if (ndoc) {
27516  char *buff = ndoc;
27517  strncpy(buff, methods[i].ml_doc, ldoc);
27518  buff += ldoc;
27519  strncpy(buff, "swig_ptr: ", 10);
27520  buff += 10;
27521  SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
27522  methods[i].ml_doc = ndoc;
27523  }
27524  }
27525  }
27526  }
27527  }
27528  }
27529 
27530 #ifdef __cplusplus
27531 }
27532 #endif
27533 
27534 /* -----------------------------------------------------------------------------*
27535  * Partial Init method
27536  * -----------------------------------------------------------------------------*/
27537 
27538 #ifdef __cplusplus
27539 extern "C"
27540 #endif
27541 
27542 SWIGEXPORT
27543 #if PY_VERSION_HEX >= 0x03000000
27544 PyObject*
27545 #else
27546 void
27547 #endif
27548 SWIG_init(void) {
27549  PyObject *m, *d, *md;
27550 #if PY_VERSION_HEX >= 0x03000000
27551  static struct PyModuleDef SWIG_module = {
27552 # if PY_VERSION_HEX >= 0x03020000
27553  PyModuleDef_HEAD_INIT,
27554 # else
27555  {
27556  PyObject_HEAD_INIT(NULL)
27557  NULL, /* m_init */
27558  0, /* m_index */
27559  NULL, /* m_copy */
27560  },
27561 # endif
27562  (char *) SWIG_name,
27563  NULL,
27564  -1,
27565  SwigMethods,
27566  NULL,
27567  NULL,
27568  NULL,
27569  NULL
27570  };
27571 #endif
27572 
27573 #if defined(SWIGPYTHON_BUILTIN)
27574  static SwigPyClientData SwigPyObject_clientdata = {
27575  0, 0, 0, 0, 0, 0, 0
27576  };
27577  static PyGetSetDef this_getset_def = {
27578  (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
27579  };
27580  static SwigPyGetSet thisown_getset_closure = {
27581  (PyCFunction) SwigPyObject_own,
27582  (PyCFunction) SwigPyObject_own
27583  };
27584  static PyGetSetDef thisown_getset_def = {
27585  (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
27586  };
27587  PyObject *metatype_args;
27588  PyTypeObject *builtin_pytype;
27589  int builtin_base_count;
27590  swig_type_info *builtin_basetype;
27591  PyObject *tuple;
27592  PyGetSetDescrObject *static_getset;
27593  PyTypeObject *metatype;
27594  SwigPyClientData *cd;
27595  PyObject *public_interface, *public_symbol;
27596  PyObject *this_descr;
27597  PyObject *thisown_descr;
27598  PyObject *self = 0;
27599  int i;
27600 
27601  (void)builtin_pytype;
27602  (void)builtin_base_count;
27603  (void)builtin_basetype;
27604  (void)tuple;
27605  (void)static_getset;
27606  (void)self;
27607 
27608  /* metatype is used to implement static member variables. */
27609  metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
27610  assert(metatype_args);
27611  metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
27612  assert(metatype);
27613  Py_DECREF(metatype_args);
27614  metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
27615  assert(PyType_Ready(metatype) >= 0);
27616 #endif
27617 
27618  /* Fix SwigMethods to carry the callback ptrs when needed */
27619  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
27620 
27621 #if PY_VERSION_HEX >= 0x03000000
27622  m = PyModule_Create(&SWIG_module);
27623 #else
27624  m = Py_InitModule((char *) SWIG_name, SwigMethods);
27625 #endif
27626 
27627  md = d = PyModule_GetDict(m);
27628  (void)md;
27629 
27630  SWIG_InitializeModule(0);
27631 
27632 #ifdef SWIGPYTHON_BUILTIN
27633  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
27634  assert(SwigPyObject_stype);
27635  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
27636  if (!cd) {
27637  SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
27638  SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
27639  } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
27640  PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
27641 # if PY_VERSION_HEX >= 0x03000000
27642  return NULL;
27643 # else
27644  return;
27645 # endif
27646  }
27647 
27648  /* All objects have a 'this' attribute */
27649  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
27650  (void)this_descr;
27651 
27652  /* All objects have a 'thisown' attribute */
27653  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
27654  (void)thisown_descr;
27655 
27656  public_interface = PyList_New(0);
27657  public_symbol = 0;
27658  (void)public_symbol;
27659 
27660  PyDict_SetItemString(md, "__all__", public_interface);
27661  Py_DECREF(public_interface);
27662  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
27663  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
27664  for (i = 0; swig_const_table[i].name != 0; ++i)
27665  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
27666 #endif
27667 
27668  SWIG_InstallConstants(d,swig_const_table);
27669 
27670  SWIG_Python_SetConstant(d, "ADD4",SWIG_From_int(static_cast< int >(libbgp::ADD4)));
27671  SWIG_Python_SetConstant(d, "WITHDRAW4",SWIG_From_int(static_cast< int >(libbgp::WITHDRAW4)));
27672  SWIG_Python_SetConstant(d, "ADD6",SWIG_From_int(static_cast< int >(libbgp::ADD6)));
27673  SWIG_Python_SetConstant(d, "WITHDRAW6",SWIG_From_int(static_cast< int >(libbgp::WITHDRAW6)));
27674  SWIG_Python_SetConstant(d, "COLLISION",SWIG_From_int(static_cast< int >(libbgp::COLLISION)));
27675  SWIG_Python_SetConstant(d, "IPV4",SWIG_From_int(static_cast< int >(libbgp::IPV4)));
27676  SWIG_Python_SetConstant(d, "IPV6",SWIG_From_int(static_cast< int >(libbgp::IPV6)));
27677  SWIG_Python_SetConstant(d, "UNICAST",SWIG_From_int(static_cast< int >(libbgp::UNICAST)));
27678  SWIG_Python_SetConstant(d, "MULTICAST",SWIG_From_int(static_cast< int >(libbgp::MULTICAST)));
27679  SWIG_Python_SetConstant(d, "UNICAST_AND_MULTICAST",SWIG_From_int(static_cast< int >(libbgp::UNICAST_AND_MULTICAST)));
27680  SWIG_Python_SetConstant(d, "MP_BGP",SWIG_From_int(static_cast< int >(libbgp::MP_BGP)));
27681  SWIG_Python_SetConstant(d, "ROUTE_REFRESH",SWIG_From_int(static_cast< int >(libbgp::ROUTE_REFRESH)));
27682  SWIG_Python_SetConstant(d, "ORF",SWIG_From_int(static_cast< int >(libbgp::ORF)));
27683  SWIG_Python_SetConstant(d, "EXTENDED_NEXTHOP",SWIG_From_int(static_cast< int >(libbgp::EXTENDED_NEXTHOP)));
27684  SWIG_Python_SetConstant(d, "BGPSEC",SWIG_From_int(static_cast< int >(libbgp::BGPSEC)));
27685  SWIG_Python_SetConstant(d, "MULTIPLE_LABELS",SWIG_From_int(static_cast< int >(libbgp::MULTIPLE_LABELS)));
27686  SWIG_Python_SetConstant(d, "GRACEFUL_RESTART",SWIG_From_int(static_cast< int >(libbgp::GRACEFUL_RESTART)));
27687  SWIG_Python_SetConstant(d, "ASN_4B",SWIG_From_int(static_cast< int >(libbgp::ASN_4B)));
27688  SWIG_Python_SetConstant(d, "ADD_PATH",SWIG_From_int(static_cast< int >(libbgp::ADD_PATH)));
27689  SWIG_Python_SetConstant(d, "ENHANCED_ROUTE_REFRESH",SWIG_From_int(static_cast< int >(libbgp::ENHANCED_ROUTE_REFRESH)));
27690  SWIG_Python_SetConstant(d, "F_ROUTE",SWIG_From_int(static_cast< int >(libbgp::F_ROUTE)));
27691  SWIG_Python_SetConstant(d, "F_AS_PATH",SWIG_From_int(static_cast< int >(libbgp::F_AS_PATH)));
27692  SWIG_Python_SetConstant(d, "F_COMMUNITY",SWIG_From_int(static_cast< int >(libbgp::F_COMMUNITY)));
27693  SWIG_Python_SetConstant(d, "M_EQ",SWIG_From_int(static_cast< int >(libbgp::M_EQ)));
27694  SWIG_Python_SetConstant(d, "M_NE",SWIG_From_int(static_cast< int >(libbgp::M_NE)));
27695  SWIG_Python_SetConstant(d, "M_GT",SWIG_From_int(static_cast< int >(libbgp::M_GT)));
27696  SWIG_Python_SetConstant(d, "M_LT",SWIG_From_int(static_cast< int >(libbgp::M_LT)));
27697  SWIG_Python_SetConstant(d, "M_GE",SWIG_From_int(static_cast< int >(libbgp::M_GE)));
27698  SWIG_Python_SetConstant(d, "M_LE",SWIG_From_int(static_cast< int >(libbgp::M_LE)));
27699  SWIG_Python_SetConstant(d, "M_HAS_ASN",SWIG_From_int(static_cast< int >(libbgp::M_HAS_ASN)));
27700  SWIG_Python_SetConstant(d, "M_NOT_HAS_ASN",SWIG_From_int(static_cast< int >(libbgp::M_NOT_HAS_ASN)));
27701  SWIG_Python_SetConstant(d, "M_FROM_ASN",SWIG_From_int(static_cast< int >(libbgp::M_FROM_ASN)));
27702  SWIG_Python_SetConstant(d, "M_NOT_FROM_ASN",SWIG_From_int(static_cast< int >(libbgp::M_NOT_FROM_ASN)));
27703  SWIG_Python_SetConstant(d, "M_HAS_COMMUNITY",SWIG_From_int(static_cast< int >(libbgp::M_HAS_COMMUNITY)));
27704  SWIG_Python_SetConstant(d, "M_NOT_HAS_COMMUNITY",SWIG_From_int(static_cast< int >(libbgp::M_NOT_HAS_COMMUNITY)));
27705  SWIG_Python_SetConstant(d, "NOP",SWIG_From_int(static_cast< int >(libbgp::NOP)));
27706  SWIG_Python_SetConstant(d, "ACCEPT",SWIG_From_int(static_cast< int >(libbgp::ACCEPT)));
27707  SWIG_Python_SetConstant(d, "REJECT",SWIG_From_int(static_cast< int >(libbgp::REJECT)));
27708  SWIG_Python_SetConstant(d, "NO_EXPORT",SWIG_From_int(static_cast< int >(libbgp::NO_EXPORT)));
27709  SWIG_Python_SetConstant(d, "NO_ADVERTISE",SWIG_From_int(static_cast< int >(libbgp::NO_ADVERTISE)));
27710  SWIG_Python_SetConstant(d, "NO_EXPORT_SUBCONFED",SWIG_From_int(static_cast< int >(libbgp::NO_EXPORT_SUBCONFED)));
27711  PyDict_SetItemString(md,(char*)"cvar", SWIG_globals());
27712  SWIG_addvarlink(SWIG_globals(),(char*)"bgp_error_code_str",Swig_var_bgp_error_code_str_get, Swig_var_bgp_error_code_str_set);
27713  SWIG_addvarlink(SWIG_globals(),(char*)"bgp_header_error_subcode_str",Swig_var_bgp_header_error_subcode_str_get, Swig_var_bgp_header_error_subcode_str_set);
27714  SWIG_addvarlink(SWIG_globals(),(char*)"bgp_open_error_subcode_str",Swig_var_bgp_open_error_subcode_str_get, Swig_var_bgp_open_error_subcode_str_set);
27715  SWIG_addvarlink(SWIG_globals(),(char*)"bgp_update_error_str",Swig_var_bgp_update_error_str_get, Swig_var_bgp_update_error_str_set);
27716  SWIG_addvarlink(SWIG_globals(),(char*)"bgp_fsm_error_str",Swig_var_bgp_fsm_error_str_get, Swig_var_bgp_fsm_error_str_set);
27717  SWIG_addvarlink(SWIG_globals(),(char*)"bgp_cease_error_str",Swig_var_bgp_cease_error_str_get, Swig_var_bgp_cease_error_str_set);
27718  SWIG_Python_SetConstant(d, "E_UNSPEC",SWIG_From_int(static_cast< int >(libbgp::E_UNSPEC)));
27719  SWIG_Python_SetConstant(d, "E_HEADER",SWIG_From_int(static_cast< int >(libbgp::E_HEADER)));
27720  SWIG_Python_SetConstant(d, "E_OPEN",SWIG_From_int(static_cast< int >(libbgp::E_OPEN)));
27721  SWIG_Python_SetConstant(d, "E_UPDATE",SWIG_From_int(static_cast< int >(libbgp::E_UPDATE)));
27722  SWIG_Python_SetConstant(d, "E_HOLD",SWIG_From_int(static_cast< int >(libbgp::E_HOLD)));
27723  SWIG_Python_SetConstant(d, "E_FSM",SWIG_From_int(static_cast< int >(libbgp::E_FSM)));
27724  SWIG_Python_SetConstant(d, "E_CEASE",SWIG_From_int(static_cast< int >(libbgp::E_CEASE)));
27725  SWIG_Python_SetConstant(d, "E_UNSPEC_HEADER",SWIG_From_int(static_cast< int >(libbgp::E_UNSPEC_HEADER)));
27726  SWIG_Python_SetConstant(d, "E_SYNC",SWIG_From_int(static_cast< int >(libbgp::E_SYNC)));
27727  SWIG_Python_SetConstant(d, "E_LENGTH",SWIG_From_int(static_cast< int >(libbgp::E_LENGTH)));
27728  SWIG_Python_SetConstant(d, "E_TYPE",SWIG_From_int(static_cast< int >(libbgp::E_TYPE)));
27729  SWIG_Python_SetConstant(d, "E_UNSPEC_OPEN",SWIG_From_int(static_cast< int >(libbgp::E_UNSPEC_OPEN)));
27730  SWIG_Python_SetConstant(d, "E_VERSION",SWIG_From_int(static_cast< int >(libbgp::E_VERSION)));
27731  SWIG_Python_SetConstant(d, "E_PEER_AS",SWIG_From_int(static_cast< int >(libbgp::E_PEER_AS)));
27732  SWIG_Python_SetConstant(d, "E_BGP_ID",SWIG_From_int(static_cast< int >(libbgp::E_BGP_ID)));
27733  SWIG_Python_SetConstant(d, "E_OPT_PARAM",SWIG_From_int(static_cast< int >(libbgp::E_OPT_PARAM)));
27734  SWIG_Python_SetConstant(d, "E_AUTH_FAILED",SWIG_From_int(static_cast< int >(libbgp::E_AUTH_FAILED)));
27735  SWIG_Python_SetConstant(d, "E_HOLD_TIME",SWIG_From_int(static_cast< int >(libbgp::E_HOLD_TIME)));
27736  SWIG_Python_SetConstant(d, "E_CAPABILITY",SWIG_From_int(static_cast< int >(libbgp::E_CAPABILITY)));
27737  SWIG_Python_SetConstant(d, "E_UNSPEC_UPDATE",SWIG_From_int(static_cast< int >(libbgp::E_UNSPEC_UPDATE)));
27738  SWIG_Python_SetConstant(d, "E_ATTR_LIST",SWIG_From_int(static_cast< int >(libbgp::E_ATTR_LIST)));
27739  SWIG_Python_SetConstant(d, "E_BAD_WELL_KNOWN",SWIG_From_int(static_cast< int >(libbgp::E_BAD_WELL_KNOWN)));
27740  SWIG_Python_SetConstant(d, "E_MISS_WELL_KNOWN",SWIG_From_int(static_cast< int >(libbgp::E_MISS_WELL_KNOWN)));
27741  SWIG_Python_SetConstant(d, "E_ATTR_FLAG",SWIG_From_int(static_cast< int >(libbgp::E_ATTR_FLAG)));
27742  SWIG_Python_SetConstant(d, "E_ATTR_LEN",SWIG_From_int(static_cast< int >(libbgp::E_ATTR_LEN)));
27743  SWIG_Python_SetConstant(d, "E_ORIGIN",SWIG_From_int(static_cast< int >(libbgp::E_ORIGIN)));
27744  SWIG_Python_SetConstant(d, "E_AS_LOOP",SWIG_From_int(static_cast< int >(libbgp::E_AS_LOOP)));
27745  SWIG_Python_SetConstant(d, "E_NEXT_HOP",SWIG_From_int(static_cast< int >(libbgp::E_NEXT_HOP)));
27746  SWIG_Python_SetConstant(d, "E_OPT_ATTR",SWIG_From_int(static_cast< int >(libbgp::E_OPT_ATTR)));
27747  SWIG_Python_SetConstant(d, "E_NETFIELD",SWIG_From_int(static_cast< int >(libbgp::E_NETFIELD)));
27748  SWIG_Python_SetConstant(d, "E_AS_PATH",SWIG_From_int(static_cast< int >(libbgp::E_AS_PATH)));
27749  SWIG_Python_SetConstant(d, "E_UNSPEC_FSM",SWIG_From_int(static_cast< int >(libbgp::E_UNSPEC_FSM)));
27750  SWIG_Python_SetConstant(d, "E_OPEN_SENT",SWIG_From_int(static_cast< int >(libbgp::E_OPEN_SENT)));
27751  SWIG_Python_SetConstant(d, "E_OPEN_CONFIRM",SWIG_From_int(static_cast< int >(libbgp::E_OPEN_CONFIRM)));
27752  SWIG_Python_SetConstant(d, "E_ESTABLISHED",SWIG_From_int(static_cast< int >(libbgp::E_ESTABLISHED)));
27753  SWIG_Python_SetConstant(d, "E_UNSPEC_CEASE",SWIG_From_int(static_cast< int >(libbgp::E_UNSPEC_CEASE)));
27754  SWIG_Python_SetConstant(d, "E_MAX_PREFIX",SWIG_From_int(static_cast< int >(libbgp::E_MAX_PREFIX)));
27755  SWIG_Python_SetConstant(d, "E_SHUTDOWN",SWIG_From_int(static_cast< int >(libbgp::E_SHUTDOWN)));
27756  SWIG_Python_SetConstant(d, "E_DECONF",SWIG_From_int(static_cast< int >(libbgp::E_DECONF)));
27757  SWIG_Python_SetConstant(d, "E_RESET",SWIG_From_int(static_cast< int >(libbgp::E_RESET)));
27758  SWIG_Python_SetConstant(d, "E_REJECT",SWIG_From_int(static_cast< int >(libbgp::E_REJECT)));
27759  SWIG_Python_SetConstant(d, "E_CONFGCHANGE",SWIG_From_int(static_cast< int >(libbgp::E_CONFGCHANGE)));
27760  SWIG_Python_SetConstant(d, "E_COLLISION",SWIG_From_int(static_cast< int >(libbgp::E_COLLISION)));
27761  SWIG_Python_SetConstant(d, "E_RESOURCES",SWIG_From_int(static_cast< int >(libbgp::E_RESOURCES)));
27762  SWIG_Python_SetConstant(d, "BGP_FSM_BUFFER_SIZE",SWIG_From_int(static_cast< int >(4096)));
27763  SWIG_Python_SetConstant(d, "IDLE",SWIG_From_int(static_cast< int >(libbgp::IDLE)));
27764  SWIG_Python_SetConstant(d, "OPEN_SENT",SWIG_From_int(static_cast< int >(libbgp::OPEN_SENT)));
27765  SWIG_Python_SetConstant(d, "OPEN_CONFIRM",SWIG_From_int(static_cast< int >(libbgp::OPEN_CONFIRM)));
27766  SWIG_Python_SetConstant(d, "ESTABLISHED",SWIG_From_int(static_cast< int >(libbgp::ESTABLISHED)));
27767  SWIG_Python_SetConstant(d, "BROKEN",SWIG_From_int(static_cast< int >(libbgp::BROKEN)));
27768  SWIG_Python_SetConstant(d, "FATAL",SWIG_From_int(static_cast< int >(libbgp::FATAL)));
27769  SWIG_Python_SetConstant(d, "ERROR",SWIG_From_int(static_cast< int >(libbgp::ERROR)));
27770  SWIG_Python_SetConstant(d, "WARN",SWIG_From_int(static_cast< int >(libbgp::WARN)));
27771  SWIG_Python_SetConstant(d, "INFO",SWIG_From_int(static_cast< int >(libbgp::INFO)));
27772  SWIG_Python_SetConstant(d, "DEBUG",SWIG_From_int(static_cast< int >(libbgp::DEBUG)));
27773  SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(libbgp::OPEN)));
27774  SWIG_Python_SetConstant(d, "UPDATE",SWIG_From_int(static_cast< int >(libbgp::UPDATE)));
27775  SWIG_Python_SetConstant(d, "NOTIFICATION",SWIG_From_int(static_cast< int >(libbgp::NOTIFICATION)));
27776  SWIG_Python_SetConstant(d, "KEEPALIVE",SWIG_From_int(static_cast< int >(libbgp::KEEPALIVE)));
27777  SWIG_Python_SetConstant(d, "UNKNOW",SWIG_From_int(static_cast< int >(libbgp::UNKNOW)));
27778  SWIG_Python_SetConstant(d, "RESERVED",SWIG_From_int(static_cast< int >(libbgp::RESERVED)));
27779  SWIG_Python_SetConstant(d, "ORIGIN",SWIG_From_int(static_cast< int >(libbgp::ORIGIN)));
27780  SWIG_Python_SetConstant(d, "AS_PATH",SWIG_From_int(static_cast< int >(libbgp::AS_PATH)));
27781  SWIG_Python_SetConstant(d, "NEXT_HOP",SWIG_From_int(static_cast< int >(libbgp::NEXT_HOP)));
27782  SWIG_Python_SetConstant(d, "MULTI_EXIT_DISC",SWIG_From_int(static_cast< int >(libbgp::MULTI_EXIT_DISC)));
27783  SWIG_Python_SetConstant(d, "LOCAL_PREF",SWIG_From_int(static_cast< int >(libbgp::LOCAL_PREF)));
27784  SWIG_Python_SetConstant(d, "ATOMIC_AGGREGATE",SWIG_From_int(static_cast< int >(libbgp::ATOMIC_AGGREGATE)));
27785  SWIG_Python_SetConstant(d, "AGGREATOR",SWIG_From_int(static_cast< int >(libbgp::AGGREATOR)));
27786  SWIG_Python_SetConstant(d, "COMMUNITY",SWIG_From_int(static_cast< int >(libbgp::COMMUNITY)));
27787  SWIG_Python_SetConstant(d, "MP_REACH_NLRI",SWIG_From_int(static_cast< int >(libbgp::MP_REACH_NLRI)));
27788  SWIG_Python_SetConstant(d, "MP_UNREACH_NLRI",SWIG_From_int(static_cast< int >(libbgp::MP_UNREACH_NLRI)));
27789  SWIG_Python_SetConstant(d, "AS4_PATH",SWIG_From_int(static_cast< int >(libbgp::AS4_PATH)));
27790  SWIG_Python_SetConstant(d, "AS4_AGGREGATOR",SWIG_From_int(static_cast< int >(libbgp::AS4_AGGREGATOR)));
27791  SWIG_Python_SetConstant(d, "IGP",SWIG_From_int(static_cast< int >(libbgp::IGP)));
27792  SWIG_Python_SetConstant(d, "EGP",SWIG_From_int(static_cast< int >(libbgp::EGP)));
27793  SWIG_Python_SetConstant(d, "INCOMPLETE",SWIG_From_int(static_cast< int >(libbgp::INCOMPLETE)));
27794  SWIG_Python_SetConstant(d, "AS_SET",SWIG_From_int(static_cast< int >(libbgp::AS_SET)));
27795  SWIG_Python_SetConstant(d, "AS_SEQUENCE",SWIG_From_int(static_cast< int >(libbgp::AS_SEQUENCE)));
27796 #if PY_VERSION_HEX >= 0x03000000
27797  return m;
27798 #else
27799  return;
27800 #endif
27801 }
27802 
LogLevel
Log levels for logger (BgpLogHandler)
GetTypeFromBuffer
Get type of attribute from buffer.
Definition: libbgp.py:1572
RouteEventType
Type of route events.
Definition: route-event.h:23
Atomic aggregate attribute.
Includes
Test if an address is inside a prefix.
Definition: libbgp.py:511
IPv6 Route/Prefix related utilities.
Definition: libbgp.py:487
bool restoreAsPath()
Restore the AS_PATH attribute to four octets ASN flavor.
The BgpRib4 (IPv4 BGP Routing Information Base) class.
Definition: bgp-rib4.h:91
const char * bgp_error_code_str[7]
Error strings for BGP error codes.
Definition: bgp-errcode.cc:19
The BGP FSM output handler.
The BgpOpenMessage class.
ssize_t length() const
Get size in bytes required to serialize the object.
The BgpPathAttrib class.
virtual ssize_t length() const
Get size in bytes required to serialize the object.
MP-BGP ReachNlri IPv6 NLRI class.
The BGP Finite State Machine.
The FdOutHandler class.
int stop()
Stop the FSM. (Any -> Idle)
Definition: bgp-fsm.cc:157
Afi
Address Family Identifiers.
Definition: bgp-afi.h:20
The BgpCapabilityMpBgp class.
size_t getCount() const
Get number of ASNs in the segment.
ssize_t length() const
Get size in bytes required to serialize the object.
MP-BGP UnreachNlri container for unknow AFI/SAFI.
BgpFilterOP
The filter operation.
Definition: bgp-filter.h:69
ssize_t length() const
Get size in bytes required to serialize the object.
The base of BGP RIB entry.
Definition: bgp-rib.h:17
The BgpCapabilityUnknow class.
The BgpCapability base class.
The AS_PATH filtering rule.
Definition: bgp-filter.h:166
The BgpSink class.
Definition: bgp-sink.h:29
BgpFilterRuleRouteMatchType
Matching type of IP prefix rule.
Definition: bgp-filter.h:36
The BgpNotificationMessage object.
ssize_t length() const
Get size in bytes required to serialize the object.
The RouteEventBus class.
Definition: libbgp.py:324
Probe for collision detection.
Definition: libbgp.py:284
The IPv4 route filtering rule.
Definition: bgp-filter.h:148
bool cidr_to_mask6(uint8_t src, uint8_t dst[16])
Convert IPv6 mask in CIDR notation to bytes array.
Definition: prefix6.cc:158
The RealtimeClock class.
Definition: libbgp.py:2641
The serializable base class.
Definition: libbgp.py:101
ssize_t length() const
Get size in bytes required to serialize the object.
AS4_AGGREGATOR attribute.
The BgpCapability4BytesAsn class.
Route event receiver.
The BgpFsm class.
Definition: bgp-fsm.h:44
The base of BgpFilterRule.
Definition: bgp-filter.h:79
BgpState
BGP Finite State Machine status.
Definition: bgp-fsm.h:32
BgpFilterRuleCommunityMatchType
Matching type of COMMUNITY rule.
Definition: bgp-filter.h:60
The BgpRib4Entry class.
Definition: bgp-rib4.h:70
uint8_t nexthop_global[16]
Global IPv6 address of the next hop in network btyes order.
Definition: bgp-rib6.h:84
bool downgradeAggregator()
Downgrade aggregator to two octets.
uint32_t cidr_to_mask(uint8_t cidr)
Convert netmask in CIDR notation to network bytes integer.
Definition: prefix4.cc:33
An Route6WithdrawEvent.
Definition: libbgp.py:258
uint8_t default_nexthop6_global[16]
The default global IPv6 nexthop to use.
Definition: bgp-config.h:261
ssize_t length() const
Get size in bytes required to serialize the object.
bool restoreAggregator()
Restore aggregator attribute from as4_aggregator.
ssize_t length() const
Get size in bytes required to serialize the object.
ssize_t length() const
Get size in bytes required to serialize the object.
The BgpRib6Entry class.
Definition: bgp-rib6.h:68
const char * bgp_fsm_error_str[4]
Error strings for BGP FSM error subcodes.
Definition: bgp-errcode.cc:78
Local Pref attribute.
File descriptor out handler.
The BgpMessage base class.
Definition: bgp-message.h:35
An Route4WithdrawEvent.
Definition: libbgp.py:202
const char * bgp_cease_error_str[9]
Error strings for BGP cease error subcodes.
Definition: bgp-errcode.cc:89
IPv4 Route/Prefix related utilities.
Definition: libbgp.py:400
bool v6addr_is_zero(const uint8_t prefix[16])
Test if a IPv6 addresss is all zero.
Definition: prefix6.cc:195
ssize_t length() const
Get size in bytes required to serialize the object.
The BgpRib6 (IPv6 BGP Routing Information Base) class.
Definition: bgp-rib6.h:100
An Route4AddEvent.
Definition: libbgp.py:172
The BgpKeepaliveMessage class.
An Route6AddEvent.
Definition: libbgp.py:228
uint8_t default_nexthop6_linklocal[16]
The default link-local IPv6 nexthop to use.
Definition: bgp-config.h:275
const char * bgp_open_error_subcode_str[8]
Error strings for BGP open message error subcodes.
Definition: bgp-errcode.cc:44
A Clock implementation to use system time as time.
Definition: bgp-afi.h:14
bool mask_ipv6(const uint8_t prefix[16], uint8_t mask, uint8_t masked_addr[16])
Mask a IPv6 address with given netmask.
Definition: prefix6.cc:173
MP-BGP Reach/Unreach NLRI base class.
ssize_t length() const
Get size in bytes required to serialize the object.
The BGP FSM configuration object.
Definition: bgp-config.h:28
The BgpLogHandler class.
int start()
send OPEN message to peer. (IDLE -> OpenSent)
Definition: bgp-fsm.cc:118
The BgpBadMessage class.
bool dropNonTransitive()
Drop all non-transitive attributes from the update message.
Route/Prefix related utilities.
Definition: libbgp.py:355
An AS_PATH or AS4_PATH segment.
BgpFilterRuleAsPathMatchType
Matching type of AS_PATH rule.
Definition: bgp-filter.h:49
const char * bgp_update_error_str[12]
Error strings for BGP update message error subcodes.
Definition: bgp-errcode.cc:59
The prefix filtering rule.
Definition: bgp-filter.h:102
The RouteEventReceiver interface.
Definition: libbgp.py:310
size_t getBytesInSink() const
Get amount to data in sink.
Definition: bgp-sink.cc:155
The BGP filtering rules set.
Definition: bgp-filter.h:211
Multi Exit Discriminator attribute.
The BgpPacket class.
Definition: bgp-packet.h:26
ssize_t length() const
Get size in bytes required to serialize the object.
The Clock interface.
Definition: clock.h:31
BGP community attribute.
ssize_t length() const
Get size in bytes required to serialize the object.
const char * bgp_header_error_subcode_str[4]
Error strings for BGP header error subcodes.
Definition: bgp-errcode.cc:33
The COMMUNITY filtering rule.
Definition: bgp-filter.h:193
ssize_t length() const
Get size in bytes required to serialize the object.
The IPv6 route filtering rule.
Definition: bgp-filter.h:157
Includes
Test if an address is inside a prefix.
Definition: libbgp.py:424
uint8_t nexthop_linklocal[16]
Link local IPv6 address of the next hop in network btyes order. (all 0 if not avaliable) ...
Definition: bgp-rib6.h:91
MP-BGP ReachNlri container for unknow AFI/SAFI.
bool downgradeAsPath()
Downgrade the AS_PATH to two octets flavor.
int resetSoft()
Perform a soft reset.
Definition: bgp-fsm.cc:313
int tick()
Tick the clock (Check for time-based events)
Definition: bgp-fsm.cc:290
The BgpUpdateMessage class.
MP-BGP UnreachNlri IPv6 class.
ssize_t length() const
Get size in bytes required to serialize the object.
The RouteEvent base.
Definition: libbgp.py:150